/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 1.3.31
 * 
 * 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
template<class T> class SwigValueWrapper {
    T *tt;
public:
    SwigValueWrapper() : tt(0) { }
    SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
    SwigValueWrapper(const T& t) : tt(new T(t)) { }
    ~SwigValueWrapper() { delete tt; } 
    SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
    operator T&() const { return *tt; }
    T *operator&() { return tt; }
private:
    SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
};
#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)
#   if (__SUNPRO_CC <= 0x560)
#     define SWIGTEMPLATEDISAMBIGUATOR template
#   else
#     define SWIGTEMPLATEDISAMBIGUATOR 
#   endif
# 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 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


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

/* -----------------------------------------------------------------------------
 * swigrun.swg
 *
 * This file contains generic CAPI 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 "3"

/* 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 is strictly necessary, ie, if you have problems
  with your compiler or so.
*/

#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

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


/* 
   Flags/methods for returning states.
   
   The swig conversion methods, as ConvertPtr, return and 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 swig versions, you usually write code as:

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

   Now you can be more explicit as:

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

   that seems to be the same, 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
   requires also to SWIG_ConvertPtr to return new result values, 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 *);
typedef struct swig_type_info *(*swig_dycast_func)(void **);

/* Structure to store inforomation 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 (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;
}


/* think of this as a c++ template<> or a scheme macro */
#define SWIG_TypeCheck_Template(comparison, ty)         \
  if (ty) {                                             \
    swig_cast_info *iter = ty->cast;                    \
    while (iter) {                                      \
      if (comparison) {                                 \
        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

/*
  Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
  SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
}

/* Same as previous function, except strcmp is replaced with a pointer comparison */
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
  SWIG_TypeCheck_Template(iter->type == from, into);
}

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

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

/*
  Return the name associated with this type
*/
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




/* 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
#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) {
    PyObject *old_str = PyObject_Str(value);
    PyErr_Clear();
    Py_XINCREF(type);
    PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
    Py_DECREF(old_str);
    Py_DECREF(value);
  } else {
    PyErr_Format(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" {
#if 0
} /* cc-mode */
#endif
#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;

#ifdef __cplusplus
#if 0
{ /* cc-mode */
#endif
}
#endif


/* -----------------------------------------------------------------------------
 * See the LICENSE file for information on copyright, usage and redistribution
 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
 *
 * 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)
#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(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(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)                         PySwigClientData_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 */

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

/* 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, int min, int 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 "), min);
      return 0;
    }
  }  
  if (!PyTuple_Check(args)) {
    PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
    return 0;
  } else {
    register int l = PyTuple_GET_SIZE(args);
    if (l < min) {
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
		   name, (min == max ? "" : "at least "), min, l);
      return 0;
    } else if (l > max) {
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
		   name, (min == max ? "" : "at most "), max, 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)

#ifdef __cplusplus
extern "C" {
#if 0
} /* cc-mode */
#endif
#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;
}

/* PySwigClientData */

typedef struct {
  PyObject *klass;
  PyObject *newraw;
  PyObject *newargs;
  PyObject *destroy;
  int delargs;
  int implicitconv;
} PySwigClientData;

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

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


SWIGRUNTIME PySwigClientData * 
PySwigClientData_New(PyObject* obj)
{
  if (!obj) {
    return 0;
  } else {
    PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
    /* 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;
    return data;
  }
}

SWIGRUNTIME void 
PySwigClientData_Del(PySwigClientData* data)
{
  Py_XDECREF(data->newraw);
  Py_XDECREF(data->newargs);
  Py_XDECREF(data->destroy);
}

/* =============== PySwigObject =====================*/

typedef struct {
  PyObject_HEAD
  void *ptr;
  swig_type_info *ty;
  int own;
  PyObject *next;
} PySwigObject;

SWIGRUNTIME PyObject *
PySwigObject_long(PySwigObject *v)
{
  return PyLong_FromVoidPtr(v->ptr);
}

SWIGRUNTIME PyObject *
PySwigObject_format(const char* fmt, PySwigObject *v)
{
  PyObject *res = NULL;
  PyObject *args = PyTuple_New(1);
  if (args) {
    if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
      PyObject *ofmt = PyString_FromString(fmt);
      if (ofmt) {
	res = PyString_Format(ofmt,args);
	Py_DECREF(ofmt);
      }
      Py_DECREF(args);
    }
  }
  return res;
}

SWIGRUNTIME PyObject *
PySwigObject_oct(PySwigObject *v)
{
  return PySwigObject_format("%o",v);
}

SWIGRUNTIME PyObject *
PySwigObject_hex(PySwigObject *v)
{
  return PySwigObject_format("%x",v);
}

SWIGRUNTIME PyObject *
#ifdef METH_NOARGS
PySwigObject_repr(PySwigObject *v)
#else
PySwigObject_repr(PySwigObject *v, PyObject *args)
#endif
{
  const char *name = SWIG_TypePrettyName(v->ty);
  PyObject *hex = PySwigObject_hex(v);    
  PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
  Py_DECREF(hex);
  if (v->next) {
#ifdef METH_NOARGS
    PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
#else
    PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
#endif
    PyString_ConcatAndDel(&repr,nrep);
  }
  return repr;  
}

SWIGRUNTIME int
PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
{
#ifdef METH_NOARGS
  PyObject *repr = PySwigObject_repr(v);
#else
  PyObject *repr = PySwigObject_repr(v, NULL);
#endif
  if (repr) {
    fputs(PyString_AsString(repr), fp);
    Py_DECREF(repr);
    return 0; 
  } else {
    return 1; 
  }
}

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

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

SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);

SWIGRUNTIME PyTypeObject*
PySwigObject_type(void) {
  static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
  return type;
}

SWIGRUNTIMEINLINE int
PySwigObject_Check(PyObject *op) {
  return ((op)->ob_type == PySwigObject_type())
    || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
}

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

SWIGRUNTIME void
PySwigObject_dealloc(PyObject *v)
{
  PySwigObject *sobj = (PySwigObject *) v;
  PyObject *next = sobj->next;
  if (sobj->own) {
    swig_type_info *ty = sobj->ty;
    PySwigClientData *data = ty ? (PySwigClientData *) 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 temporal object to carry the destroy operation */
	PyObject *tmp = PySwigObject_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);
    } else {
      const char *name = SWIG_TypePrettyName(ty);
#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
      printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
#endif
    }
  } 
  Py_XDECREF(next);
  PyObject_DEL(v);
}

SWIGRUNTIME PyObject* 
PySwigObject_append(PyObject* v, PyObject* next)
{
  PySwigObject *sobj = (PySwigObject *) v;
#ifndef METH_O
  PyObject *tmp = 0;
  if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
  next = tmp;
#endif
  if (!PySwigObject_Check(next)) {
    return NULL;
  }
  sobj->next = next;
  Py_INCREF(next);
  return SWIG_Py_Void();
}

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

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

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

SWIGINTERN PyObject*
PySwigObject_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
    {
      PySwigObject *sobj = (PySwigObject *)v;
      PyObject *obj = PyBool_FromLong(sobj->own);
      if (val) {
#ifdef METH_NOARGS
	if (PyObject_IsTrue(val)) {
	  PySwigObject_acquire(v);
	} else {
	  PySwigObject_disown(v);
	}
#else
	if (PyObject_IsTrue(val)) {
	  PySwigObject_acquire(v,args);
	} else {
	  PySwigObject_disown(v,args);
	}
#endif
      } 
      return obj;
    }
}

#ifdef METH_O
static PyMethodDef
swigobject_methods[] = {
  {(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
  {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS,  (char *)"aquires ownership of the pointer"},
  {(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
  {(char *)"append",  (PyCFunction)PySwigObject_append,  METH_O,       (char *)"appends another 'this' object"},
  {(char *)"next",    (PyCFunction)PySwigObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
  {(char *)"__repr__",(PyCFunction)PySwigObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
  {0, 0, 0, 0}  
};
#else
static PyMethodDef
swigobject_methods[] = {
  {(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
  {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS,  (char *)"aquires ownership of the pointer"},
  {(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
  {(char *)"append",  (PyCFunction)PySwigObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
  {(char *)"next",    (PyCFunction)PySwigObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
  {(char *)"__repr__",(PyCFunction)PySwigObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
  {0, 0, 0, 0}  
};
#endif

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

SWIGRUNTIME PyTypeObject*
_PySwigObject_type(void) {
  static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
  
  static PyNumberMethods PySwigObject_as_number = {
    (binaryfunc)0, /*nb_add*/
    (binaryfunc)0, /*nb_subtract*/
    (binaryfunc)0, /*nb_multiply*/
    (binaryfunc)0, /*nb_divide*/
    (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*/
    (coercion)0,   /*nb_coerce*/
    (unaryfunc)PySwigObject_long, /*nb_int*/
    (unaryfunc)PySwigObject_long, /*nb_long*/
    (unaryfunc)0,                 /*nb_float*/
    (unaryfunc)PySwigObject_oct,  /*nb_oct*/
    (unaryfunc)PySwigObject_hex,  /*nb_hex*/
#if PY_VERSION_HEX >= 0x02020000
    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
    0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
#endif
  };

  static PyTypeObject pyswigobject_type;  
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp
      = {
	PyObject_HEAD_INIT(NULL)
	0,				    /* ob_size */
	(char *)"PySwigObject",		    /* tp_name */
	sizeof(PySwigObject),		    /* tp_basicsize */
	0,			            /* tp_itemsize */
	(destructor)PySwigObject_dealloc,   /* tp_dealloc */
	(printfunc)PySwigObject_print,	    /* tp_print */
#if PY_VERSION_HEX < 0x02020000
	(getattrfunc)PySwigObject_getattr,  /* tp_getattr */ 
#else
	(getattrfunc)0,			    /* tp_getattr */ 
#endif
	(setattrfunc)0,			    /* tp_setattr */ 
	(cmpfunc)PySwigObject_compare,	    /* tp_compare */ 
	(reprfunc)PySwigObject_repr,	    /* tp_repr */    
	&PySwigObject_as_number,	    /* tp_as_number */
	0,				    /* tp_as_sequence */
	0,				    /* tp_as_mapping */
	(hashfunc)0,			    /* tp_hash */
	(ternaryfunc)0,			    /* tp_call */
	(reprfunc)PySwigObject_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 */
	0,                                  /* 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
#ifdef COUNT_ALLOCS
	0,0,0,0                             /* tp_alloc -> tp_next */
#endif
      };
    pyswigobject_type = tmp;
    pyswigobject_type.ob_type = &PyType_Type;
    type_init = 1;
  }
  return &pyswigobject_type;
}

SWIGRUNTIME PyObject *
PySwigObject_New(void *ptr, swig_type_info *ty, int own)
{
  PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_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;
} PySwigPacked;

SWIGRUNTIME int
PySwigPacked_print(PySwigPacked *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 *
PySwigPacked_repr(PySwigPacked *v)
{
  char result[SWIG_BUFFER_SIZE];
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
    return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
  } else {
    return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
  }  
}

SWIGRUNTIME PyObject *
PySwigPacked_str(PySwigPacked *v)
{
  char result[SWIG_BUFFER_SIZE];
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
    return PyString_FromFormat("%s%s", result, v->ty->name);
  } else {
    return PyString_FromString(v->ty->name);
  }  
}

SWIGRUNTIME int
PySwigPacked_compare(PySwigPacked *v, PySwigPacked *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* _PySwigPacked_type(void);

SWIGRUNTIME PyTypeObject*
PySwigPacked_type(void) {
  static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
  return type;
}

SWIGRUNTIMEINLINE int
PySwigPacked_Check(PyObject *op) {
  return ((op)->ob_type == _PySwigPacked_type()) 
    || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
}

SWIGRUNTIME void
PySwigPacked_dealloc(PyObject *v)
{
  if (PySwigPacked_Check(v)) {
    PySwigPacked *sobj = (PySwigPacked *) v;
    free(sobj->pack);
  }
  PyObject_DEL(v);
}

SWIGRUNTIME PyTypeObject*
_PySwigPacked_type(void) {
  static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
  static PyTypeObject pyswigpacked_type;
  static int type_init = 0;  
  if (!type_init) {
    const PyTypeObject tmp
      = {
	PyObject_HEAD_INIT(NULL)
	0,				    /* ob_size */	
	(char *)"PySwigPacked",		    /* tp_name */	
	sizeof(PySwigPacked),		    /* tp_basicsize */	
	0,				    /* tp_itemsize */	
	(destructor)PySwigPacked_dealloc,   /* tp_dealloc */	
	(printfunc)PySwigPacked_print,	    /* tp_print */   	
	(getattrfunc)0,			    /* tp_getattr */ 	
	(setattrfunc)0,			    /* tp_setattr */ 	
	(cmpfunc)PySwigPacked_compare,	    /* tp_compare */ 	
	(reprfunc)PySwigPacked_repr,	    /* tp_repr */    	
	0,	                            /* tp_as_number */	
	0,				    /* tp_as_sequence */
	0,				    /* tp_as_mapping */	
	(hashfunc)0,			    /* tp_hash */	
	(ternaryfunc)0,			    /* tp_call */	
	(reprfunc)PySwigPacked_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
#ifdef COUNT_ALLOCS
	0,0,0,0                             /* tp_alloc -> tp_next */
#endif
      };
    pyswigpacked_type = tmp;
    pyswigpacked_type.ob_type = &PyType_Type;
    type_init = 1;
  }
  return &pyswigpacked_type;
}

SWIGRUNTIME PyObject *
PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
{
  PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_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 *
PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
{
  if (PySwigPacked_Check(obj)) {
    PySwigPacked *sobj = (PySwigPacked *)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 PyString_FromString("this");
}

SWIGRUNTIME PyObject *
SWIG_This(void)
{
  static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
  return swig_this;
}

/* #define SWIG_PYTHON_SLOW_GETSET_THIS */

SWIGRUNTIME PySwigObject *
SWIG_Python_GetSwigThis(PyObject *pyobj) 
{
  if (PySwigObject_Check(pyobj)) {
    return (PySwigObject *) pyobj;
  } else {
    PyObject *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 && !PySwigObject_Check(obj)) {
      /* a PyObject is called 'this', try to get the 'real this'
	 PySwigObject from it */ 
      return SWIG_Python_GetSwigThis(obj);
    }
    return (PySwigObject *)obj;
  }
}

/* Acquire a pointer value */

SWIGRUNTIME int
SWIG_Python_AcquirePtr(PyObject *obj, int own) {
  if (own) {
    PySwigObject *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) {
  if (!obj) return SWIG_ERROR;
  if (obj == Py_None) {
    if (ptr) *ptr = 0;
    return SWIG_OK;
  } else {
    PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
    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 = (PySwigObject *)sobj->next;
	  } else {
	    if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
	    break;
	  }
	}
      } else {
	if (ptr) *ptr = vptr;
	break;
      }
    }
    if (sobj) {
      if (own) *own = sobj->own;
      if (flags & SWIG_POINTER_DISOWN) {
	sobj->own = 0;
      }
      return SWIG_OK;
    } else {
      int res = SWIG_ERROR;
      if (flags & SWIG_POINTER_IMPLICIT_CONV) {
	PySwigClientData *data = ty ? (PySwigClientData *) 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) {
	      PySwigObject *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) return SWIG_ERROR;
      *ptr = SWIG_TypeCast(tc,vptr);
    } 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 = PySwigPacked_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, whitout calling __init__, and set the
  'this' attribute.
*/

SWIGRUNTIME PyObject* 
SWIG_Python_NewShadowInstance(PySwigClientData *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 {
    PyObject *dict = PyDict_New();
    PyDict_SetItem(dict, SWIG_This(), swig_this);
    inst = PyInstance_NewRaw(data->newargs, dict);
    Py_DECREF(dict);
  }
  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 {
    PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
    if (sthis) {
      PySwigObject_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(void *ptr, swig_type_info *type, int flags) {
  if (!ptr) {
    return SWIG_Py_Void();
  } else {
    int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
    PyObject *robj = PySwigObject_New(ptr, type, own);
    PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
    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 ? PySwigPacked_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
    type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
				    (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
    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
SWIG_Python_DestroyModule(void *vptr)
{
  swig_module_info *swig_module = (swig_module_info *) vptr;
  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) {
      PySwigClientData *data = (PySwigClientData *) ty->clientdata;
      if (data) PySwigClientData_Del(data);
    }
  }
  Py_DECREF(SWIG_This());
}

SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info *swig_module) {
  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);
  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);
  }
}

/* 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 = PyString_FromString(type); 
  PyObject *obj = PyDict_GetItem(cache, key);
  swig_type_info *descriptor;
  if (obj) {
    descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
  } else {
    swig_module_info *swig_module = SWIG_Python_GetModule();
    descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
    if (descriptor) {
      obj = PyCObject_FromVoidPtr(descriptor, NULL);
      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) {
      PyObject *old_str = PyObject_Str(value);
      Py_XINCREF(type);
      PyErr_Clear();
      if (infront) {
	PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
      } else {
	PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
      }
      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 *
PySwigObject_GetDesc(PyObject *self)
{
  PySwigObject *v = (PySwigObject *)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 && PySwigObject_Check(obj)) {
      const char *otype = (const char *) PySwigObject_GetDesc(obj);
      if (otype) {
	PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%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 ? PyString_AsString(str) : 0;
	if (cstr) {
	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
		       type, otype, 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 argnum, int flags) {
  void *result;
  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
    PyErr_Clear();
    if (flags & SWIG_POINTER_EXCEPTION) {
      SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
      SWIG_Python_ArgFail(argnum);
    }
  }
  return result;
}


#ifdef __cplusplus
#if 0
{ /* cc-mode */
#endif
}
#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) 

/* -----------------------------------------------------------------------------
 * See the LICENSE file for information on copyright, usage and redistribution
 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
 *
 * 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 usefull 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() = 0;

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

  GCItem::~GCItem()
  {
  }

  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());
      } else {
        SWIG_Python_AddErrorMsg(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

/* simple thread abstraction for pthreads on win32 */
#ifdef __THREAD__
# define __PTHREAD__
# if defined(_WIN32) || defined(__WIN32__)
#  define pthread_mutex_lock EnterCriticalSection
#  define pthread_mutex_unlock LeaveCriticalSection
#  define pthread_mutex_t CRITICAL_SECTION
#  define SWIG_MUTEX_INIT(var) var
# else
#  include <pthread.h>
#  define SWIG_MUTEX_INIT(var) var = PTHREAD_MUTEX_INITIALIZER 
# endif
#endif

#ifdef  __PTHREAD__
  struct Guard
  {
    pthread_mutex_t *_mutex;
    
    Guard(pthread_mutex_t &mutex) : _mutex(&mutex)
    {
      pthread_mutex_lock(_mutex);
    }
    
    ~Guard()
    {
      pthread_mutex_unlock(_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* /* name */) const {
      return true;
    }
    
    virtual void swig_set_inner(const char* /* name */, bool /* val */) const {
    }

  /* ownership management */
  private:
    typedef std::map<void*, GCItem_var> ownership_map;
    mutable ownership_map owner;
#ifdef __PTHREAD__
    static pthread_mutex_t swig_mutex_own;
#endif

  public:
    template <typename Type>
    void swig_acquire_ownership_array(Type *vptr)  const
    {
      if (vptr) {
        SWIG_GUARD(swig_mutex_own);
        owner[vptr] = new GCArray_T<Type>(vptr);
      }
    }
    
    template <typename Type>
    void swig_acquire_ownership(Type *vptr)  const
    {
      if (vptr) {
        SWIG_GUARD(swig_mutex_own);
        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);
        owner[vptr] = new GCItem_Object(own);
      }
    }
    
    int swig_release_ownership(void *vptr) const
    {
      int own = 0;
      if (vptr) {
        SWIG_GUARD(swig_mutex_own);
        ownership_map::iterator iter = owner.find(vptr);
        if (iter != owner.end()) {
          own = iter->second->get_own();
          owner.erase(iter);
        }
      }
      return own;
    }
  };

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

#define SWIG_name    "_quickfix"

#define SWIGVERSION 0x010331 
#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 PyObject_ptr {
  protected:
    PyObject *_obj;

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

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

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


namespace swig {
  struct PyObject_var : PyObject_ptr {
    PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
    
    PyObject_var & 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>
#ifndef LLONG_MIN
# define LLONG_MIN	LONG_LONG_MIN
#endif
#ifndef LLONG_MAX
# define LLONG_MAX	LONG_LONG_MAX
#endif
#ifndef ULLONG_MAX
# define ULLONG_MAX	ULONG_LONG_MAX
#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 (PyString_Check(obj)) {
    char *cstr; Py_ssize_t len;
    PyString_AsStringAndSize(obj, &cstr, &len);
    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 {
	*cptr = PyString_AsString(obj);
      }
    }
    if (psize) *psize = len + 1;
    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_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
    } else {
      return PyString_FromStringAndSize(carray, static_cast< int >(size));
    }
  } else {
    return SWIG_Py_Void();
  }
}


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

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->getValue();
  }




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)
{
  if (obj == Py_True) {
    if (val) *val = true;
    return SWIG_OK;
  } else if (obj == Py_False) {
    if (val) *val = false;
    return SWIG_OK;
  } else {
    long v = 0;
    int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
    if (SWIG_IsOK(res) && val) *val = v ? true : false;
    return res;
  }
}


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

SWIGINTERN 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::PyObject_var 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::PyObject_var result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
    swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"onCreate", (char *)"(O)" ,(PyObject *)obj0);
#endif
    if (result == NULL) {
      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::PyObject_var 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::PyObject_var result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
    swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"onLogon", (char *)"(O)" ,(PyObject *)obj0);
#endif
    if (result == NULL) {
      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::PyObject_var 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::PyObject_var result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
    swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"onLogout", (char *)"(O)" ,(PyObject *)obj0);
#endif
    if (result == NULL) {
      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::PyObject_var obj0;
    obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_FIX__Message,  0 );
    swig::PyObject_var 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::PyObject_var result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#else
    swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"toAdmin", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#endif
    if (result == NULL) {
      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::PyObject_var obj0;
    obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_FIX__Message,  0 );
    swig::PyObject_var 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::PyObject_var result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#else
    swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"toApp", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#endif
    if (result == NULL) {
      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::PyObject_var obj0;
    obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_FIX__Message,  0 );
    swig::PyObject_var 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::PyObject_var result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#else
    swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"fromAdmin", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#endif
    if (result == NULL) {
      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::PyObject_var obj0;
    obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_FIX__Message,  0 );
    swig::PyObject_var 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::PyObject_var result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#else
    swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"fromApp", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#endif
    if (result == NULL) {
      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 ;
  IntArray *result = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntArray___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  IntArray *arg1 = (IntArray *) 0 ;
  size_t arg2 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntArray_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  IntArray *arg1 = (IntArray *) 0 ;
  int *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntArray_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int *arg1 = (int *) 0 ;
  IntArray *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::Exception *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Exception_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Exception *arg1 = (FIX::Exception *) 0 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      std::string const &_result_ref =  ((arg1)->type);
      result = (std::string *) &_result_ref;
    }
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Exception_detail_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Exception *arg1 = (FIX::Exception *) 0 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      std::string const &_result_ref =  ((arg1)->detail);
      result = (std::string *) &_result_ref;
    }
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Exception___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Exception *arg1 = (FIX::Exception *) 0 ;
  std::string result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::DataDictionaryNotFound *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DataDictionaryNotFound__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::DataDictionaryNotFound *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionaryNotFound_version_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionaryNotFound *arg1 = (FIX::DataDictionaryNotFound *) 0 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      std::string const &_result_ref =  ((arg1)->version);
      result = (std::string *) &_result_ref;
    }
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::FieldNotFound *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FieldNotFound__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  FIX::FieldNotFound *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FieldNotFound__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldNotFound *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldNotFound_field_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldNotFound *arg1 = (FIX::FieldNotFound *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::FieldConvertError *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FieldConvertError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldConvertError *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::MessageParseError *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MessageParseError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageParseError *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::InvalidMessage *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidMessage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InvalidMessage *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::ConfigError *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfigError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ConfigError *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::RuntimeError *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RuntimeError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RuntimeError *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::InvalidTagNumber *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidTagNumber__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  FIX::InvalidTagNumber *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidTagNumber__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InvalidTagNumber *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_InvalidTagNumber_field_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InvalidTagNumber *arg1 = (FIX::InvalidTagNumber *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::RequiredTagMissing *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RequiredTagMissing__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  FIX::RequiredTagMissing *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RequiredTagMissing__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RequiredTagMissing *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RequiredTagMissing_field_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RequiredTagMissing *arg1 = (FIX::RequiredTagMissing *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::TagNotDefinedForMessage *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TagNotDefinedForMessage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  FIX::TagNotDefinedForMessage *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TagNotDefinedForMessage__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TagNotDefinedForMessage *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_TagNotDefinedForMessage_field_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TagNotDefinedForMessage *arg1 = (FIX::TagNotDefinedForMessage *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::NoTagValue *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTagValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  FIX::NoTagValue *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTagValue__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoTagValue *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_NoTagValue_field_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoTagValue *arg1 = (FIX::NoTagValue *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::IncorrectTagValue *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IncorrectTagValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  FIX::IncorrectTagValue *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IncorrectTagValue__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IncorrectTagValue *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IncorrectTagValue_field_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IncorrectTagValue *arg1 = (FIX::IncorrectTagValue *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::IncorrectDataFormat *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IncorrectDataFormat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  FIX::IncorrectDataFormat *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IncorrectDataFormat__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IncorrectDataFormat *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IncorrectDataFormat_field_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IncorrectDataFormat *arg1 = (FIX::IncorrectDataFormat *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::IncorrectMessageStructure *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IncorrectMessageStructure__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IncorrectMessageStructure *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::DuplicateFieldNumber *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DuplicateFieldNumber__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DuplicateFieldNumber *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::InvalidMessageType *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidMessageType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InvalidMessageType *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::UnsupportedMessageType *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnsupportedMessageType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnsupportedMessageType *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::UnsupportedVersion *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnsupportedVersion__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnsupportedVersion *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::TagOutOfOrder *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TagOutOfOrder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  FIX::TagOutOfOrder *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TagOutOfOrder__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TagOutOfOrder *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_TagOutOfOrder_field_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TagOutOfOrder *arg1 = (FIX::TagOutOfOrder *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::RepeatedTag *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RepeatedTag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  FIX::RepeatedTag *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RepeatedTag__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RepeatedTag *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RepeatedTag_field_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RepeatedTag *arg1 = (FIX::RepeatedTag *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::RepeatingGroupCountMismatch *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RepeatingGroupCountMismatch__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  FIX::RepeatingGroupCountMismatch *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RepeatingGroupCountMismatch__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RepeatingGroupCountMismatch *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RepeatingGroupCountMismatch_field_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RepeatingGroupCountMismatch *arg1 = (FIX::RepeatingGroupCountMismatch *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::DoNotSend *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoNotSend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DoNotSend *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::RejectLogon *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RejectLogon__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RejectLogon *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::SessionNotFound *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionNotFound__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionNotFound *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::IOException *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOException__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IOException *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SocketException__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::SocketException *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_SocketException_errorToWhat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SocketException *arg1 = (FIX::SocketException *) 0 ;
  std::string result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SocketException_error_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SocketException *arg1 = (FIX::SocketException *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SocketSendFailed__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::SocketSendFailed *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::SocketRecvFailed *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SocketRecvFailed__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::SocketRecvFailed *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SocketCloseFailed__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::SocketCloseFailed *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::FieldBase *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldBase_getField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldBase_getString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      std::string const &_result_ref = ((FIX::FieldBase const *)arg1)->getString();
      result = (std::string *) &_result_ref;
    }
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldBase_getValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:FieldBase_getValue",&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_getValue" "', argument " "1"" of type '" "FIX::FieldBase const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    {
      std::string const &_result_ref = ((FIX::FieldBase const *)arg1)->getValue();
      result = (std::string *) &_result_ref;
    }
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldBase_getLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldBase_getTotal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldBase___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  std::string result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  std::ostream *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      std::ostream &_result_ref = FIX::operator <<(*arg1,(FIX::FieldBase const &)*arg2);
      result = (std::ostream *) &_result_ref;
    }
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StringField__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string *arg2 = 0 ;
  FIX::StringField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StringField__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  FIX::StringField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringField_getValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = (FIX::StringField *) 0 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      std::string const &_result_ref = ((FIX::StringField const *)arg1)->getValue();
      result = (std::string *) &_result_ref;
    }
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap___lt____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  FIX::StringField *arg2 = 0 ;
  bool result;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap___gt____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap___gt____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  FIX::StringField *arg2 = 0 ;
  bool result;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  FIX::StringField *arg2 = 0 ;
  bool result;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  FIX::StringField *arg2 = 0 ;
  bool result;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap___le____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap___le____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  FIX::StringField *arg2 = 0 ;
  bool result;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap___ge____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap___ge____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  FIX::StringField *arg2 = 0 ;
  bool result;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap___lt____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap___lt____SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::StringField *arg2 = 0 ;
  bool result;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap___gt____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap___gt____SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::StringField *arg2 = 0 ;
  bool result;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap___gt__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); 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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap___gt____SWIG_1(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap___eq____SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::StringField *arg2 = 0 ;
  bool result;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap___ne____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap___ne____SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::StringField *arg2 = 0 ;
  bool result;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap___le____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap___le____SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::StringField *arg2 = 0 ;
  bool result;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap___le__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); 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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap___le____SWIG_1(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap___ge____SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::StringField *arg2 = 0 ;
  bool result;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap___ge__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); 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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap___ge____SWIG_1(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
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 ;
  FIX::CharField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CharField__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  FIX::CharField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CharField_getValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CharField *arg1 = (FIX::CharField *) 0 ;
  char result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (char)((FIX::CharField const *)arg1)->getValue();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::DoubleField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoubleField__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  FIX::DoubleField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoubleField__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  FIX::DoubleField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleField_setValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 3); 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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          return _wrap_DoubleField_setValue__SWIG_0(self, args);
        }
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'DoubleField_setValue'.\n  Possible C/C++ prototypes are:\n    setValue(double,int)\n    setValue(double)\n");
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleField_getValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DoubleField *arg1 = (FIX::DoubleField *) 0 ;
  double result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (double)((FIX::DoubleField const *)arg1)->getValue();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::IntField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IntField__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  FIX::IntField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntField_getValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IntField *arg1 = (FIX::IntField *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (int)((FIX::IntField const *)arg1)->getValue();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::BoolField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BoolField__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  FIX::BoolField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolField_getValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BoolField *arg1 = (FIX::BoolField *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (bool)((FIX::BoolField const *)arg1)->getValue();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::UtcTimeStampField *result = 0 ;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeStampField__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  UtcTimeStamp *arg2 = 0 ;
  FIX::UtcTimeStampField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeStampField__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  bool arg2 ;
  FIX::UtcTimeStampField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeStampField__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  FIX::UtcTimeStampField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UtcTimeStampField_getValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeStampField *arg1 = (FIX::UtcTimeStampField *) 0 ;
  UtcTimeStamp result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = ((FIX::UtcTimeStampField const *)arg1)->getValue();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new UtcTimeStamp(static_cast< const UtcTimeStamp& >(result))), SWIGTYPE_p_UtcTimeStamp, SWIG_POINTER_OWN |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::UtcDateField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcDateField__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  FIX::UtcDateField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UtcDateField_getValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcDateField *arg1 = (FIX::UtcDateField *) 0 ;
  UtcDate result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = ((FIX::UtcDateField const *)arg1)->getValue();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new UtcDate(static_cast< const UtcDate& >(result))), SWIGTYPE_p_UtcDate, SWIG_POINTER_OWN |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::UtcTimeOnlyField *result = 0 ;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeOnlyField__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  UtcTimeOnly *arg2 = 0 ;
  FIX::UtcTimeOnlyField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeOnlyField__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  bool arg2 ;
  FIX::UtcTimeOnlyField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeOnlyField__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  FIX::UtcTimeOnlyField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UtcTimeOnlyField_getValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeOnlyField *arg1 = (FIX::UtcTimeOnlyField *) 0 ;
  UtcTimeOnly result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = ((FIX::UtcTimeOnlyField const *)arg1)->getValue();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new UtcTimeOnly(static_cast< const UtcTimeOnly& >(result))), SWIGTYPE_p_UtcTimeOnly, SWIG_POINTER_OWN |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::CheckSumField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CheckSumField__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  FIX::CheckSumField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CheckSumField_getValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CheckSumField *arg1 = (FIX::CheckSumField *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (int)((FIX::CheckSumField const *)arg1)->getValue();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::FieldMap *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FieldMap__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FieldMap__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int *arg1 ;
  FIX::FieldMap *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FieldMap__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = 0 ;
  FIX::FieldMap *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FieldMap(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_FieldMap__SWIG_3(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_FieldMap'.\n  Possible C/C++ prototypes are:\n    FIX::FieldMap(message_order const &)\n    FIX::FieldMap()\n    FIX::FieldMap(int const [])\n    FIX::FieldMap(FIX::FieldMap const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->setField((FIX::FieldBase const &)*arg2,arg3);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->setField((FIX::FieldBase const &)*arg2);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->setField(arg2,(std::string const &)*arg3);
    }
    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;
    }
    
    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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_setField(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 3); 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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          return _wrap_FieldMap_setField__SWIG_2(self, args);
        }
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FieldMap_setField'.\n  Possible C/C++ prototypes are:\n    setField(FIX::FieldBase const &,bool)\n    setField(FIX::FieldBase const &)\n    setField(int,std::string const &)\n");
  return NULL;
}


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 ;
  FIX::FieldBase *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      {
        FIX::FieldBase &_result_ref = ((FIX::FieldMap const *)arg1)->getField(*arg2);
        result = (FIX::FieldBase *) &_result_ref;
      }
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      {
        std::string const &_result_ref = ((FIX::FieldMap const *)arg1)->getField(arg2);
        result = (std::string *) &_result_ref;
      }
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_getField(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); 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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_FieldMap_getField__SWIG_1(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FieldMap_getField'.\n  Possible C/C++ prototypes are:\n    getField(FIX::FieldBase &)\n    getField(int)\n");
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_getFieldRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  FIX::FieldBase *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      {
        FIX::FieldBase const &_result_ref = ((FIX::FieldMap const *)arg1)->getFieldRef(arg2);
        result = (FIX::FieldBase *) &_result_ref;
      }
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_getFieldPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  FIX::FieldBase *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (FIX::FieldBase *)((FIX::FieldMap const *)arg1)->getFieldPtr(arg2);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_isSetField(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); 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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_FieldMap_isSetField__SWIG_1(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FieldMap_isSetField'.\n  Possible C/C++ prototypes are:\n    isSetField(FIX::FieldBase const &)\n    isSetField(int)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_addGroup(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 4); 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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          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) {
            SWIG_PYTHON_THREAD_END_BLOCK;
            return _wrap_FieldMap_addGroup__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FieldMap_addGroup'.\n  Possible C/C++ prototypes are:\n    addGroup(int,FIX::FieldMap const &,bool)\n    addGroup(int,FIX::FieldMap const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::FieldMap *result = 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      {
        FIX::FieldMap &_result_ref = ((FIX::FieldMap const *)arg1)->getGroup(arg2,arg3,*arg4);
        result = (FIX::FieldMap *) &_result_ref;
      }
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::FieldMap *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      {
        FIX::FieldMap &_result_ref = ((FIX::FieldMap const *)arg1)->getGroupRef(arg2,arg3);
        result = (FIX::FieldMap *) &_result_ref;
      }
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::FieldMap *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (FIX::FieldMap *)((FIX::FieldMap const *)arg1)->getGroupPtr(arg2,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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_removeGroup(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 3); 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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          return _wrap_FieldMap_removeGroup__SWIG_0(self, args);
        }
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FieldMap_removeGroup'.\n  Possible C/C++ prototypes are:\n    removeGroup(int,int)\n    removeGroup(int)\n");
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_hasGroup__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_hasGroup(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 3); 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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          return _wrap_FieldMap_hasGroup__SWIG_1(self, args);
        }
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FieldMap_hasGroup'.\n  Possible C/C++ prototypes are:\n    hasGroup(int)\n    hasGroup(int,int)\n");
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_groupCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_isEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_totalFields(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      std::string &_result_ref = ((FIX::FieldMap const *)arg1)->calculateString(*arg2,arg3);
      result = (std::string *) &_result_ref;
    }
    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()) );
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      std::string &_result_ref = ((FIX::FieldMap const *)arg1)->calculateString(*arg2);
      result = (std::string *) &_result_ref;
    }
    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()) );
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_calculateString(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 3); 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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          return _wrap_FieldMap_calculateString__SWIG_0(self, args);
        }
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FieldMap_calculateString'.\n  Possible C/C++ prototypes are:\n    calculateString(std::string &,bool)\n    calculateString(std::string &)\n");
  return NULL;
}


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 ;
  int result;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_calculateLength__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_calculateLength(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 4); ii++) {
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          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) {
            SWIG_PYTHON_THREAD_END_BLOCK;
            return _wrap_FieldMap_calculateLength__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FieldMap_calculateLength'.\n  Possible C/C++ prototypes are:\n    calculateLength(int,int,int)\n    calculateLength(int,int)\n    calculateLength(int)\n    calculateLength()\n");
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_calculateTotal__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_calculateTotal__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_calculateTotal(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_FieldMap_calculateTotal__SWIG_0(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FieldMap_calculateTotal'.\n  Possible C/C++ prototypes are:\n    calculateTotal(int)\n    calculateTotal()\n");
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  FIX::FieldMap::iterator result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  FIX::FieldMap::iterator result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_g_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  FIX::FieldMap::g_iterator result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_g_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  FIX::FieldMap::g_iterator result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 headerOrder_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable headerOrder is read-only.");
  return 1;
}


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


SWIGINTERN PyObject *_wrap_new_Message__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Message__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  bool arg2 ;
  FIX::Message *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (FIX::Message *)new FIX::Message((std::string const &)*arg1,arg2);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Message__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::Message *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (FIX::Message *)new FIX::Message((std::string const &)*arg1);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::Message *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (FIX::Message *)new FIX::Message((std::string const &)*arg1,(FIX::DataDictionary const &)*arg2,arg3);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::Message *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (FIX::Message *)new FIX::Message((std::string const &)*arg1,(FIX::DataDictionary const &)*arg2);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::Message *result = 0 ;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (FIX::Message *)new FIX::Message((std::string const &)*arg1,(FIX::DataDictionary const &)*arg2,(FIX::DataDictionary const &)*arg3,arg4);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::Message *result = 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (FIX::Message *)new FIX::Message((std::string const &)*arg1,(FIX::DataDictionary const &)*arg2,(FIX::DataDictionary const &)*arg3);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Message__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = 0 ;
  FIX::Message *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Message(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 4); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          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) {
            SWIG_PYTHON_THREAD_END_BLOCK;
            return _wrap_new_Message__SWIG_5(self, args);
          }
        }
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Message'.\n  Possible C/C++ prototypes are:\n    FIX::Message()\n    FIX::Message(std::string const &,bool)\n    FIX::Message(std::string const &)\n    FIX::Message(std::string const &,FIX::DataDictionary const &,bool)\n    FIX::Message(std::string const &,FIX::DataDictionary const &)\n    FIX::Message(std::string const &,FIX::DataDictionary const &,FIX::DataDictionary const &,bool)\n    FIX::Message(std::string const &,FIX::DataDictionary const &,FIX::DataDictionary const &)\n    FIX::Message(FIX::Message const &)\n");
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_InitializeXML(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  bool result;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  Group *result = 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      {
        Group &_result_ref = ((FIX::Message const *)arg1)->getGroup(arg2,*arg3);
        result = (Group *) &_result_ref;
      }
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Group, 0 |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_removeGroup(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 3); 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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          return _wrap_Message_removeGroup__SWIG_0(self, args);
        }
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Message_removeGroup'.\n  Possible C/C++ prototypes are:\n    removeGroup(unsigned int,FIX::Group &)\n    removeGroup(FIX::Group &)\n");
  return NULL;
}


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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_hasGroup(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 3); 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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          return _wrap_Message_hasGroup__SWIG_1(self, args);
        }
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Message_hasGroup'.\n  Possible C/C++ prototypes are:\n    hasGroup(FIX::Group const &)\n    hasGroup(unsigned int,FIX::Group &)\n");
  return NULL;
}


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 ;
  std::string result;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  std::string result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  std::string result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_toString__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  std::string result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  std::string *result = 0 ;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      std::string &_result_ref = ((FIX::Message const *)arg1)->toString(*arg2,arg3,arg4,arg5);
      result = (std::string *) &_result_ref;
    }
    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()) );
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  std::string *result = 0 ;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      std::string &_result_ref = ((FIX::Message const *)arg1)->toString(*arg2,arg3,arg4);
      result = (std::string *) &_result_ref;
    }
    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()) );
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      std::string &_result_ref = ((FIX::Message const *)arg1)->toString(*arg2,arg3);
      result = (std::string *) &_result_ref;
    }
    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()) );
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      std::string &_result_ref = ((FIX::Message const *)arg1)->toString(*arg2);
      result = (std::string *) &_result_ref;
    }
    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()) );
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_toString(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 5); ii++) {
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          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) {
            SWIG_PYTHON_THREAD_END_BLOCK;
            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) {
            SWIG_PYTHON_THREAD_END_BLOCK;
            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) {
              SWIG_PYTHON_THREAD_END_BLOCK;
              return _wrap_Message_toString__SWIG_4(self, args);
            }
          }
        }
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Message_toString'.\n  Possible C/C++ prototypes are:\n    toString(int,int,int)\n    toString(int,int)\n    toString(int)\n    toString()\n    toString(std::string &,int,int,int)\n    toString(std::string &,int,int)\n    toString(std::string &,int)\n    toString(std::string &)\n");
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_toXML__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  std::string result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      std::string &_result_ref = ((FIX::Message const *)arg1)->toXML(*arg2);
      result = (std::string *) &_result_ref;
    }
    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()) );
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_toXML(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_Message_toXML__SWIG_1(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Message_toXML'.\n  Possible C/C++ prototypes are:\n    toXML()\n    toXML(std::string &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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__FieldMap,  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  }
  {
    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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setString((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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->setString((std::string const &)*arg2,arg3,(FIX::DataDictionary const *)arg4);
    }
    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;
    }
    
    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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->setString((std::string const &)*arg2,arg3,(FIX::DataDictionary const *)arg4,(FIX::DataDictionary const *)arg5);
    }
    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;
    }
    
    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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_setString(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 5); 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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          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) {
            SWIG_PYTHON_THREAD_END_BLOCK;
            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) {
              SWIG_PYTHON_THREAD_END_BLOCK;
              return _wrap_Message_setString__SWIG_3(self, args);
            }
          }
        }
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Message_setString'.\n  Possible C/C++ prototypes are:\n    setString(std::string const &)\n    setString(std::string const &,bool)\n    setString(std::string const &,bool,FIX::DataDictionary const *)\n    setString(std::string const &,bool,FIX::DataDictionary const *,FIX::DataDictionary const *)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_getHeader__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  FIX::Header *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      FIX::Header const &_result_ref = ((FIX::Message const *)arg1)->getHeader();
      result = (FIX::Header *) &_result_ref;
    }
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_getHeader__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  FIX::Header *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      FIX::Header &_result_ref = (arg1)->getHeader();
      result = (FIX::Header *) &_result_ref;
    }
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_getHeader(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_Message_getHeader__SWIG_0(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Message_getHeader'.\n  Possible C/C++ prototypes are:\n    getHeader()\n    getHeader()\n");
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_getTrailer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  FIX::Header *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      FIX::Header const &_result_ref = ((FIX::Message const *)arg1)->getTrailer();
      result = (FIX::Header *) &_result_ref;
    }
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_getTrailer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  FIX::Trailer *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      FIX::Trailer &_result_ref = (arg1)->getTrailer();
      result = (FIX::Trailer *) &_result_ref;
    }
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_getTrailer(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_Message_getTrailer__SWIG_0(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Message_getTrailer'.\n  Possible C/C++ prototypes are:\n    getTrailer()\n    getTrailer()\n");
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_hasValidStructure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  int *arg2 = 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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) ); 	 
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  int result;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_bodyLength__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_bodyLength(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 4); ii++) {
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          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) {
            SWIG_PYTHON_THREAD_END_BLOCK;
            return _wrap_Message_bodyLength__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Message_bodyLength'.\n  Possible C/C++ prototypes are:\n    bodyLength(int,int,int)\n    bodyLength(int,int)\n    bodyLength(int)\n    bodyLength()\n");
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_checkSum__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  int arg2 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_checkSum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_checkSum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_Message_checkSum__SWIG_0(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Message_checkSum'.\n  Possible C/C++ prototypes are:\n    checkSum(int)\n    checkSum()\n");
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_isAdmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_isApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_isEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_isAdminMsgType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  MsgType *arg1 = 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_toApplVerID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  BeginString *arg1 = 0 ;
  ApplVerID result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_toBeginString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ApplVerID *arg1 = 0 ;
  BeginString result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_isHeaderField__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  bool result;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_isHeaderField__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_isHeaderField(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); 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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_Message_isHeaderField__SWIG_1(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Message_isHeaderField'.\n  Possible C/C++ prototypes are:\n    isHeaderField(int)\n    isHeaderField(FIX::FieldBase const &,DataDictionary const *)\n    FIX::Message::isHeaderField(FIX::FieldBase const &)\n");
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_isTrailerField__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  bool result;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_isTrailerField__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_isTrailerField(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); 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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_Message_isTrailerField__SWIG_1(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Message_isTrailerField'.\n  Possible C/C++ prototypes are:\n    isTrailerField(int)\n    isTrailerField(FIX::FieldBase const &,DataDictionary const *)\n    FIX::Message::isTrailerField(FIX::FieldBase const &)\n");
  return NULL;
}


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 ;
  SessionID result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = ((FIX::Message const *)arg1)->getSessionID((std::string const &)*arg2);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_getSessionID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  SessionID result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = ((FIX::Message const *)arg1)->getSessionID();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new SessionID(static_cast< const SessionID& >(result))), SWIGTYPE_p_SessionID, SWIG_POINTER_OWN |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_getSessionID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_Message_getSessionID__SWIG_0(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Message_getSessionID'.\n  Possible C/C++ prototypes are:\n    getSessionID(std::string const &)\n    getSessionID()\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  std::string result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  std::ostream *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      std::ostream &_result_ref = FIX::operator <<(*arg1,(FIX::Message const &)*arg2);
      result = (std::ostream *) &_result_ref;
    }
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_identifyType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  MsgType result;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = FIX::identifyType((std::string const &)*arg1);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Group__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  FIX::Group *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Group__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int *arg3 ;
  FIX::Group *result = 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::Group *result = 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Group__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Group *arg1 = 0 ;
  FIX::Group *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Group(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 3); 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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          return _wrap_new_Group__SWIG_1(self, args);
        }
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Group'.\n  Possible C/C++ prototypes are:\n    FIX::Group(int,int)\n    FIX::Group(int,int,int const [])\n    FIX::Group(int,int,message_order const &)\n    FIX::Group(FIX::Group const &)\n");
  return NULL;
}


SWIGINTERN PyObject *_wrap_Group_field(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Group *arg1 = (FIX::Group *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Group_delim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Group *arg1 = (FIX::Group *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::Group *result = 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      {
        FIX::Group &_result_ref = ((FIX::Group const *)arg1)->getGroup(arg2,*arg3);
        result = (FIX::Group *) &_result_ref;
      }
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Group, 0 |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Group_removeGroup(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 3); 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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          return _wrap_Group_removeGroup__SWIG_0(self, args);
        }
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Group_removeGroup'.\n  Possible C/C++ prototypes are:\n    removeGroup(unsigned int,FIX::Group &)\n    removeGroup(FIX::Group &)\n");
  return NULL;
}


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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Group_hasGroup(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 3); 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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          return _wrap_Group_hasGroup__SWIG_1(self, args);
        }
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Group_hasGroup'.\n  Possible C/C++ prototypes are:\n    hasGroup(FIX::Group const &)\n    hasGroup(unsigned int,FIX::Group &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelatedPartyID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelatedPartyID *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelatedPartyID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelatedPartyID *)new FIX::RelatedPartyID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelatedPartyID, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RelatedPartyID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelatedPartyID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelatedPartyID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelatedPartyID'.\n  Possible C/C++ prototypes are:\n    FIX::RelatedPartyID()\n    FIX::RelatedPartyID(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelatedPartyID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelatedPartyID, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaxPriceLevels__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::MaxPriceLevels *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEncodedIssuer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  FIX::DerivativeEncodedIssuer *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoCompIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoCompIDs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SettlInstRefID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NestedPartyID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::NestedPartyID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DetachmentPoint__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::DetachmentPoint *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LateIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::LateIndicator *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RiskEncodedSecurityDesc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskEncodedSecurityDesc *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RiskEncodedSecurityDesc")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskEncodedSecurityDesc *)new FIX::RiskEncodedSecurityDesc();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskEncodedSecurityDesc, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RiskEncodedSecurityDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  FIX::RiskEncodedSecurityDesc *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_RiskEncodedSecurityDesc",&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_RiskEncodedSecurityDesc" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RiskEncodedSecurityDesc" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskEncodedSecurityDesc *)new FIX::RiskEncodedSecurityDesc((FIX::DATA const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskEncodedSecurityDesc, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RiskEncodedSecurityDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RiskEncodedSecurityDesc__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskEncodedSecurityDesc__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskEncodedSecurityDesc'.\n  Possible C/C++ prototypes are:\n    FIX::RiskEncodedSecurityDesc()\n    FIX::RiskEncodedSecurityDesc(FIX::DATA const &)\n");
  return NULL;
}


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


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

SWIGINTERN PyObject *_wrap_new_RelationshipRiskSecuritySubType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelationshipRiskSecuritySubType *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelationshipRiskSecuritySubType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskSecuritySubType *)new FIX::RelationshipRiskSecuritySubType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskSecuritySubType, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RelationshipRiskSecuritySubType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelationshipRiskSecuritySubType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelationshipRiskSecuritySubType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelationshipRiskSecuritySubType'.\n  Possible C/C++ prototypes are:\n    FIX::RelationshipRiskSecuritySubType()\n    FIX::RelationshipRiskSecuritySubType(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelationshipRiskSecuritySubType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelationshipRiskSecuritySubType, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityListID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SecurityListID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeFlowScheduleType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::DerivativeFlowScheduleType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_EncodedSymbolLen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedSymbolLen *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_EncodedSymbolLen")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedSymbolLen *)new FIX::EncodedSymbolLen();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedSymbolLen, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedSymbolLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  FIX::EncodedSymbolLen *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncodedSymbolLen",&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_EncodedSymbolLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncodedSymbolLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedSymbolLen *)new FIX::EncodedSymbolLen((FIX::LENGTH const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedSymbolLen, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedSymbolLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_EncodedSymbolLen__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncodedSymbolLen__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncodedSymbolLen'.\n  Possible C/C++ prototypes are:\n    FIX::EncodedSymbolLen()\n    FIX::EncodedSymbolLen(FIX::LENGTH const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *EncodedSymbolLen_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__EncodedSymbolLen, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlexibleIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::FlexibleIndicator *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoExecInstRules__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoExecInstRules *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideTrdRegTimestamp__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  FIX::SideTrdRegTimestamp *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideTrdRegTimestamp__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  FIX::SideTrdRegTimestamp *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideTrdRegTimestamp__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  FIX::SideTrdRegTimestamp *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideTrdRegTimestamp(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_new_SideTrdRegTimestamp__SWIG_3(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SideTrdRegTimestamp'.\n  Possible C/C++ prototypes are:\n    FIX::SideTrdRegTimestamp()\n    FIX::SideTrdRegTimestamp(bool)\n    FIX::SideTrdRegTimestamp(FIX::UTCTIMESTAMP const &)\n    FIX::SideTrdRegTimestamp(FIX::UTCTIMESTAMP const &,bool)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeliveryForm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::DeliveryForm *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecRestatementReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ExecRestatementReason *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MidYield__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::MidYield *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContractMultiplier__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::ContractMultiplier *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_PartyAltIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PartyAltIDSource *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_PartyAltIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PartyAltIDSource *)new FIX::PartyAltIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PartyAltIDSource, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PartyAltIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::PartyAltIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_PartyAltIDSource",&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_PartyAltIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PartyAltIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PartyAltIDSource *)new FIX::PartyAltIDSource((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PartyAltIDSource, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PartyAltIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_PartyAltIDSource__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PartyAltIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PartyAltIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::PartyAltIDSource()\n    FIX::PartyAltIDSource(FIX::CHAR const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *PartyAltIDSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PartyAltIDSource, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CcyAmt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::CcyAmt *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_AllocIntermedReqType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocIntermedReqType *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocIntermedReqType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::AllocIntermedReqType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_NoNested2PartyIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoNested2PartyIDs *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNested2PartyIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoNested2PartyIDs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_UnderlyingIssuer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingIssuer *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingIssuer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingIssuer *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_LegOrderQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegOrderQty *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegOrderQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::LegOrderQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_MinTradeVol__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MinTradeVol *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MinTradeVol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::MinTradeVol *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlCurrAmt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::SettlCurrAmt *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrumentPartyRole__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::DerivativeInstrumentPartyRole *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YieldRedemptionPriceType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::YieldRedemptionPriceType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NewsRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::NewsRefID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityListTypeSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::SecurityListTypeSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ApplReqID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeFuturesValuationMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DerivativeFuturesValuationMethod *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_NoLegSecurityAltID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_NoLegSecurityAltID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoLegSecurityAltID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoLegSecurityAltID'.\n  Possible C/C++ prototypes are:\n    FIX::NoLegSecurityAltID()\n    FIX::NoLegSecurityAltID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DerivativeSecurityType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollInquiryQualifier__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::CollInquiryQualifier *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  FIX::RawData *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashSettlAgentContactPhone__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::CashSettlAgentContactPhone *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CreditRating__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::CreditRating *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContingencyType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ContingencyType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikeCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  FIX::StrikeCurrency *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeVolume__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::TradeVolume *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideTrdRegTimestampSrc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SideTrdRegTimestampSrc *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeliveryDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::DeliveryDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EmailType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::EmailType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedListExecInst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  FIX::EncodedListExecInst *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContraTradeTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  FIX::ContraTradeTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContraTradeTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  FIX::ContraTradeTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContraTradeTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  FIX::ContraTradeTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContraTradeTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_new_ContraTradeTime__SWIG_3(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ContraTradeTime'.\n  Possible C/C++ prototypes are:\n    FIX::ContraTradeTime()\n    FIX::ContraTradeTime(bool)\n    FIX::ContraTradeTime(FIX::UTCTIMESTAMP const &)\n    FIX::ContraTradeTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityMonthYearIncrement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::MaturityMonthYearIncrement *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RootPartyIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::RootPartyIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCouponPaymentDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::UnderlyingCouponPaymentDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidYield__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::BidYield *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOIQltyInd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::IOIQltyInd *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Issuer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::Issuer *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CardNumber__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::CardNumber *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_NoRelatedPartyIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoRelatedPartyIDs *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_NoRelatedPartyIDs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRelatedPartyIDs *)new FIX::NoRelatedPartyIDs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRelatedPartyIDs, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRelatedPartyIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRelatedPartyIDs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoRelatedPartyIDs",&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_NoRelatedPartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoRelatedPartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRelatedPartyIDs *)new FIX::NoRelatedPartyIDs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRelatedPartyIDs, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRelatedPartyIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_NoRelatedPartyIDs__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoRelatedPartyIDs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoRelatedPartyIDs'.\n  Possible C/C++ prototypes are:\n    FIX::NoRelatedPartyIDs()\n    FIX::NoRelatedPartyIDs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *NoRelatedPartyIDs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoRelatedPartyIDs, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoLegStipulations__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoLegStipulations *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSecurityExchange__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EXCHANGE *arg1 = 0 ;
  FIX::LegSecurityExchange *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSecurityExchange(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegSecurityExchange__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegSecurityExchange'.\n  Possible C/C++ prototypes are:\n    FIX::LegSecurityExchange()\n    FIX::LegSecurityExchange(FIX::EXCHANGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashOrderQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::CashOrderQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashOrderQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CashOrderQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CashOrderQty'.\n  Possible C/C++ prototypes are:\n    FIX::CashOrderQty()\n    FIX::CashOrderQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AccruedInterestAmt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::AccruedInterestAmt *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AccruedInterestAmt(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AccruedInterestAmt__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AccruedInterestAmt'.\n  Possible C/C++ prototypes are:\n    FIX::AccruedInterestAmt()\n    FIX::AccruedInterestAmt(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntrySeller__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::MDEntrySeller *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntrySeller(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MDEntrySeller__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MDEntrySeller'.\n  Possible C/C++ prototypes are:\n    FIX::MDEntrySeller()\n    FIX::MDEntrySeller(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::LegPrice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegPrice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegPrice'.\n  Possible C/C++ prototypes are:\n    FIX::LegPrice()\n    FIX::LegPrice(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelationshipRiskMaturityTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelationshipRiskMaturityTime *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelationshipRiskMaturityTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskMaturityTime *)new FIX::RelationshipRiskMaturityTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskMaturityTime, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelationshipRiskMaturityTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TZTIMEONLY *arg1 = 0 ;
  FIX::RelationshipRiskMaturityTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_RelationshipRiskMaturityTime",&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_RelationshipRiskMaturityTime" "', argument " "1"" of type '" "FIX::TZTIMEONLY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RelationshipRiskMaturityTime" "', argument " "1"" of type '" "FIX::TZTIMEONLY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::TZTIMEONLY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskMaturityTime *)new FIX::RelationshipRiskMaturityTime((FIX::TZTIMEONLY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskMaturityTime, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelationshipRiskMaturityTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelationshipRiskMaturityTime__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelationshipRiskMaturityTime__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelationshipRiskMaturityTime'.\n  Possible C/C++ prototypes are:\n    FIX::RelationshipRiskMaturityTime()\n    FIX::RelationshipRiskMaturityTime(FIX::TZTIMEONLY const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelationshipRiskMaturityTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelationshipRiskMaturityTime, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeliverToCompID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DeliverToCompID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeliverToCompID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DeliverToCompID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DeliverToCompID'.\n  Possible C/C++ prototypes are:\n    FIX::DeliverToCompID()\n    FIX::DeliverToCompID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetLocationID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::TargetLocationID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetLocationID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TargetLocationID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TargetLocationID'.\n  Possible C/C++ prototypes are:\n    FIX::TargetLocationID()\n    FIX::TargetLocationID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OfferForwardPoints2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  FIX::OfferForwardPoints2 *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OfferForwardPoints2(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OfferForwardPoints2__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OfferForwardPoints2'.\n  Possible C/C++ prototypes are:\n    FIX::OfferForwardPoints2()\n    FIX::OfferForwardPoints2(FIX::PRICEOFFSET const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RatioQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::RatioQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RatioQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RatioQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RatioQty'.\n  Possible C/C++ prototypes are:\n    FIX::RatioQty()\n    FIX::RatioQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MultiLegRptTypeReq__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::MultiLegRptTypeReq *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MultiLegRptTypeReq(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MultiLegRptTypeReq__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MultiLegRptTypeReq'.\n  Possible C/C++ prototypes are:\n    FIX::MultiLegRptTypeReq()\n    FIX::MultiLegRptTypeReq(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocAccount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::AllocAccount *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocAccount(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllocAccount__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllocAccount'.\n  Possible C/C++ prototypes are:\n    FIX::AllocAccount()\n    FIX::AllocAccount(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalVolumeTraded__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::TotalVolumeTraded *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalVolumeTraded(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TotalVolumeTraded__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TotalVolumeTraded'.\n  Possible C/C++ prototypes are:\n    FIX::TotalVolumeTraded()\n    FIX::TotalVolumeTraded(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LinesOfText__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::LinesOfText *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LinesOfText(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LinesOfText__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LinesOfText'.\n  Possible C/C++ prototypes are:\n    FIX::LinesOfText()\n    FIX::LinesOfText(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AccountType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::AccountType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AccountType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AccountType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AccountType'.\n  Possible C/C++ prototypes are:\n    FIX::AccountType()\n    FIX::AccountType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryPositionNo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::MDEntryPositionNo *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryPositionNo(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MDEntryPositionNo__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MDEntryPositionNo'.\n  Possible C/C++ prototypes are:\n    FIX::MDEntryPositionNo()\n    FIX::MDEntryPositionNo(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HaltReasonInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::HaltReasonInt *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HaltReasonInt(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_HaltReasonInt__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_HaltReasonInt'.\n  Possible C/C++ prototypes are:\n    FIX::HaltReasonInt()\n    FIX::HaltReasonInt(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FutSettDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::FutSettDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FutSettDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_FutSettDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_FutSettDate'.\n  Possible C/C++ prototypes are:\n    FIX::FutSettDate()\n    FIX::FutSettDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SecurityDesc *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecurityDesc__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecurityDesc'.\n  Possible C/C++ prototypes are:\n    FIX::SecurityDesc()\n    FIX::SecurityDesc(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MinQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::MinQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MinQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MinQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MinQty'.\n  Possible C/C++ prototypes are:\n    FIX::MinQty()\n    FIX::MinQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  FIX::SettlCurrency *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlCurrency__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlCurrency'.\n  Possible C/C++ prototypes are:\n    FIX::SettlCurrency()\n    FIX::SettlCurrency(FIX::CURRENCY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegOffsetValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::PegOffsetValue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegOffsetValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PegOffsetValue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PegOffsetValue'.\n  Possible C/C++ prototypes are:\n    FIX::PegOffsetValue()\n    FIX::PegOffsetValue(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityAltIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DerivativeSecurityAltIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityAltIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeSecurityAltIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeSecurityAltIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeSecurityAltIDSource()\n    FIX::DerivativeSecurityAltIDSource(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSettlPartySubIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoSettlPartySubIDs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSettlPartySubIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoSettlPartySubIDs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoSettlPartySubIDs'.\n  Possible C/C++ prototypes are:\n    FIX::NoSettlPartySubIDs()\n    FIX::NoSettlPartySubIDs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocReportID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::AllocReportID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocReportID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllocReportID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllocReportID'.\n  Possible C/C++ prototypes are:\n    FIX::AllocReportID()\n    FIX::AllocReportID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCFICode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LegCFICode *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCFICode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegCFICode__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegCFICode'.\n  Possible C/C++ prototypes are:\n    FIX::LegCFICode()\n    FIX::LegCFICode(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegFutSettDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::LegFutSettDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegFutSettDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegFutSettDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegFutSettDate'.\n  Possible C/C++ prototypes are:\n    FIX::LegFutSettDate()\n    FIX::LegFutSettDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegBenchmarkCurveName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LegBenchmarkCurveName *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegBenchmarkCurveName(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegBenchmarkCurveName__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegBenchmarkCurveName'.\n  Possible C/C++ prototypes are:\n    FIX::LegBenchmarkCurveName()\n    FIX::LegBenchmarkCurveName(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClearingFeeIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ClearingFeeIndicator *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClearingFeeIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ClearingFeeIndicator__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ClearingFeeIndicator'.\n  Possible C/C++ prototypes are:\n    FIX::ClearingFeeIndicator()\n    FIX::ClearingFeeIndicator(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BrokerOfCredit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::BrokerOfCredit *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BrokerOfCredit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_BrokerOfCredit__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BrokerOfCredit'.\n  Possible C/C++ prototypes are:\n    FIX::BrokerOfCredit()\n    FIX::BrokerOfCredit(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityListRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SecurityListRefID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityListRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecurityListRefID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecurityListRefID'.\n  Possible C/C++ prototypes are:\n    FIX::SecurityListRefID()\n    FIX::SecurityListRefID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegMaturityTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TZTIMEONLY *arg1 = 0 ;
  FIX::UnderlyingLegMaturityTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegMaturityTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingLegMaturityTime__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingLegMaturityTime'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingLegMaturityTime()\n    FIX::UnderlyingLegMaturityTime(FIX::TZTIMEONLY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NestedPartySubIDType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::NestedPartySubIDType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NestedPartySubIDType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NestedPartySubIDType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NestedPartySubIDType'.\n  Possible C/C++ prototypes are:\n    FIX::NestedPartySubIDType()\n    FIX::NestedPartySubIDType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::BidType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_BidType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BidType'.\n  Possible C/C++ prototypes are:\n    FIX::BidType()\n    FIX::BidType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::MDEntryRefID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MDEntryRefID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MDEntryRefID'.\n  Possible C/C++ prototypes are:\n    FIX::MDEntryRefID()\n    FIX::MDEntryRefID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingUnitOfMeasureQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::UnderlyingUnitOfMeasureQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingUnitOfMeasureQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingUnitOfMeasureQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingUnitOfMeasureQty'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingUnitOfMeasureQty()\n    FIX::UnderlyingUnitOfMeasureQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegMaturityDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::UnderlyingLegMaturityDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegMaturityDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingLegMaturityDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingLegMaturityDate'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingLegMaturityDate()\n    FIX::UnderlyingLegMaturityDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StartTickPriceRange__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::StartTickPriceRange *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StartTickPriceRange(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StartTickPriceRange__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StartTickPriceRange'.\n  Possible C/C++ prototypes are:\n    FIX::StartTickPriceRange()\n    FIX::StartTickPriceRange(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegContractSettlMonth__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MONTHYEAR *arg1 = 0 ;
  FIX::LegContractSettlMonth *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegContractSettlMonth(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegContractSettlMonth__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegContractSettlMonth'.\n  Possible C/C++ prototypes are:\n    FIX::LegContractSettlMonth()\n    FIX::LegContractSettlMonth(FIX::MONTHYEAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingSecurityDesc *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingSecurityDesc__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingSecurityDesc'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingSecurityDesc()\n    FIX::UnderlyingSecurityDesc(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashDistribPayRef__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::CashDistribPayRef *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashDistribPayRef(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CashDistribPayRef__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CashDistribPayRef'.\n  Possible C/C++ prototypes are:\n    FIX::CashDistribPayRef()\n    FIX::CashDistribPayRef(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuotePriceType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::QuotePriceType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuotePriceType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_QuotePriceType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_QuotePriceType'.\n  Possible C/C++ prototypes are:\n    FIX::QuotePriceType()\n    FIX::QuotePriceType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedAllocText__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  FIX::EncodedAllocText *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedAllocText(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncodedAllocText__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncodedAllocText'.\n  Possible C/C++ prototypes are:\n    FIX::EncodedAllocText()\n    FIX::EncodedAllocText(FIX::DATA const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingMaturityMonthYear__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MONTHYEAR *arg1 = 0 ;
  FIX::UnderlyingMaturityMonthYear *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingMaturityMonthYear(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingMaturityMonthYear__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingMaturityMonthYear'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingMaturityMonthYear()\n    FIX::UnderlyingMaturityMonthYear(FIX::MONTHYEAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RiskWarningLevelPercent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskWarningLevelPercent *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RiskWarningLevelPercent")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskWarningLevelPercent *)new FIX::RiskWarningLevelPercent();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskWarningLevelPercent, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RiskWarningLevelPercent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::RiskWarningLevelPercent *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_RiskWarningLevelPercent",&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_RiskWarningLevelPercent" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RiskWarningLevelPercent" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskWarningLevelPercent *)new FIX::RiskWarningLevelPercent((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskWarningLevelPercent, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RiskWarningLevelPercent(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RiskWarningLevelPercent__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskWarningLevelPercent__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskWarningLevelPercent'.\n  Possible C/C++ prototypes are:\n    FIX::RiskWarningLevelPercent()\n    FIX::RiskWarningLevelPercent(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RiskWarningLevelPercent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RiskWarningLevelPercent, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingOriginalNotionalPercentageOutstanding__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::UnderlyingOriginalNotionalPercentageOutstanding *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingOriginalNotionalPercentageOutstanding(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingOriginalNotionalPercentageOutstanding__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingOriginalNotionalPercentageOutstanding'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingOriginalNotionalPercentageOutstanding()\n    FIX::UnderlyingOriginalNotionalPercentageOutstanding(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MultilegPriceMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::MultilegPriceMethod *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MultilegPriceMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MultilegPriceMethod__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MultilegPriceMethod'.\n  Possible C/C++ prototypes are:\n    FIX::MultilegPriceMethod()\n    FIX::MultilegPriceMethod(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoFills__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TotNoFills *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoFills(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TotNoFills__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TotNoFills'.\n  Possible C/C++ prototypes are:\n    FIX::TotNoFills()\n    FIX::TotNoFills(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSettleOnOpenFlag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DerivativeSettleOnOpenFlag *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSettleOnOpenFlag(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeSettleOnOpenFlag__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeSettleOnOpenFlag'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeSettleOnOpenFlag()\n    FIX::DerivativeSettleOnOpenFlag(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingRepurchaseTerm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::UnderlyingRepurchaseTerm *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingRepurchaseTerm(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingRepurchaseTerm__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingRepurchaseTerm'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingRepurchaseTerm()\n    FIX::UnderlyingRepurchaseTerm(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RiskWarningLevelName__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskWarningLevelName *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RiskWarningLevelName")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskWarningLevelName *)new FIX::RiskWarningLevelName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskWarningLevelName, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RiskWarningLevelName(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RiskWarningLevelName__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskWarningLevelName__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskWarningLevelName'.\n  Possible C/C++ prototypes are:\n    FIX::RiskWarningLevelName()\n    FIX::RiskWarningLevelName(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RiskWarningLevelName_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RiskWarningLevelName, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeCountryOfIssue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::COUNTRY *arg1 = 0 ;
  FIX::DerivativeCountryOfIssue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeCountryOfIssue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeCountryOfIssue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeCountryOfIssue'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeCountryOfIssue()\n    FIX::DerivativeCountryOfIssue(FIX::COUNTRY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ListMethod *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ListMethod__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ListMethod'.\n  Possible C/C++ prototypes are:\n    FIX::ListMethod()\n    FIX::ListMethod(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCPProgram__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingCPProgram *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCPProgram(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingCPProgram__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingCPProgram'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingCPProgram()\n    FIX::UnderlyingCPProgram(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriceDelta__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::PriceDelta *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriceDelta(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PriceDelta__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PriceDelta'.\n  Possible C/C++ prototypes are:\n    FIX::PriceDelta()\n    FIX::PriceDelta(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefSeqNum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SEQNUM *arg1 = 0 ;
  FIX::RefSeqNum *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefSeqNum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RefSeqNum__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RefSeqNum'.\n  Possible C/C++ prototypes are:\n    FIX::RefSeqNum()\n    FIX::RefSeqNum(FIX::SEQNUM const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AutoAcceptIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::AutoAcceptIndicator *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AutoAcceptIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AutoAcceptIndicator__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AutoAcceptIndicator'.\n  Possible C/C++ prototypes are:\n    FIX::AutoAcceptIndicator()\n    FIX::AutoAcceptIndicator(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDImplicitDelete__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::MDImplicitDelete *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDImplicitDelete(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MDImplicitDelete__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MDImplicitDelete'.\n  Possible C/C++ prototypes are:\n    FIX::MDImplicitDelete()\n    FIX::MDImplicitDelete(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoStipulations__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoStipulations *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoStipulations(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoStipulations__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoStipulations'.\n  Possible C/C++ prototypes are:\n    FIX::NoStipulations()\n    FIX::NoStipulations(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClearingBusinessDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::ClearingBusinessDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClearingBusinessDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ClearingBusinessDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ClearingBusinessDate'.\n  Possible C/C++ prototypes are:\n    FIX::ClearingBusinessDate()\n    FIX::ClearingBusinessDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_NoRelationshipRiskLimits__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoRelationshipRiskLimits *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_NoRelationshipRiskLimits")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRelationshipRiskLimits *)new FIX::NoRelationshipRiskLimits();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRelationshipRiskLimits, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRelationshipRiskLimits__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRelationshipRiskLimits *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoRelationshipRiskLimits",&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_NoRelationshipRiskLimits" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoRelationshipRiskLimits" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRelationshipRiskLimits *)new FIX::NoRelationshipRiskLimits((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRelationshipRiskLimits, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRelationshipRiskLimits(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_NoRelationshipRiskLimits__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoRelationshipRiskLimits__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoRelationshipRiskLimits'.\n  Possible C/C++ prototypes are:\n    FIX::NoRelationshipRiskLimits()\n    FIX::NoRelationshipRiskLimits(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *NoRelationshipRiskLimits_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoRelationshipRiskLimits, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocationID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LocationID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocationID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LocationID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LocationID'.\n  Possible C/C++ prototypes are:\n    FIX::LocationID()\n    FIX::LocationID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Currency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  FIX::Currency *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Currency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Currency__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Currency'.\n  Possible C/C++ prototypes are:\n    FIX::Currency()\n    FIX::Currency(FIX::CURRENCY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RoutingType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::RoutingType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RoutingType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RoutingType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RoutingType'.\n  Possible C/C++ prototypes are:\n    FIX::RoutingType()\n    FIX::RoutingType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingStrikePrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::UnderlyingStrikePrice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingStrikePrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingStrikePrice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingStrikePrice'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingStrikePrice()\n    FIX::UnderlyingStrikePrice(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidTradeType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::BidTradeType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidTradeType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_BidTradeType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BidTradeType'.\n  Possible C/C++ prototypes are:\n    FIX::BidTradeType()\n    FIX::BidTradeType(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelationshipRiskInstrumentOperator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelationshipRiskInstrumentOperator *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelationshipRiskInstrumentOperator")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskInstrumentOperator *)new FIX::RelationshipRiskInstrumentOperator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskInstrumentOperator, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RelationshipRiskInstrumentOperator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelationshipRiskInstrumentOperator__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelationshipRiskInstrumentOperator__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelationshipRiskInstrumentOperator'.\n  Possible C/C++ prototypes are:\n    FIX::RelationshipRiskInstrumentOperator()\n    FIX::RelationshipRiskInstrumentOperator(FIX::INT const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelationshipRiskInstrumentOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelationshipRiskInstrumentOperator, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingAttachmentPoint__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::UnderlyingAttachmentPoint *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingAttachmentPoint(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingAttachmentPoint__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingAttachmentPoint'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingAttachmentPoint()\n    FIX::UnderlyingAttachmentPoint(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoRejQuotes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TotNoRejQuotes *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoRejQuotes(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TotNoRejQuotes__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TotNoRejQuotes'.\n  Possible C/C++ prototypes are:\n    FIX::TotNoRejQuotes()\n    FIX::TotNoRejQuotes(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrdStatusReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::OrdStatusReqID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrdStatusReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OrdStatusReqID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OrdStatusReqID'.\n  Possible C/C++ prototypes are:\n    FIX::OrdStatusReqID()\n    FIX::OrdStatusReqID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SenderCompID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SenderCompID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SenderCompID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SenderCompID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SenderCompID'.\n  Possible C/C++ prototypes are:\n    FIX::SenderCompID()\n    FIX::SenderCompID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrdRejReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::OrdRejReason *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrdRejReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OrdRejReason__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OrdRejReason'.\n  Possible C/C++ prototypes are:\n    FIX::OrdRejReason()\n    FIX::OrdRejReason(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityMonthYearIncrementUnits__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::MaturityMonthYearIncrementUnits *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityMonthYearIncrementUnits(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MaturityMonthYearIncrementUnits__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MaturityMonthYearIncrementUnits'.\n  Possible C/C++ prototypes are:\n    FIX::MaturityMonthYearIncrementUnits()\n    FIX::MaturityMonthYearIncrementUnits(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DisplayWhen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::DisplayWhen *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DisplayWhen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DisplayWhen__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DisplayWhen'.\n  Possible C/C++ prototypes are:\n    FIX::DisplayWhen()\n    FIX::DisplayWhen(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplQueueAction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ApplQueueAction *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplQueueAction(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ApplQueueAction__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ApplQueueAction'.\n  Possible C/C++ prototypes are:\n    FIX::ApplQueueAction()\n    FIX::ApplQueueAction(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistTransType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::RegistTransType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistTransType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RegistTransType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RegistTransType'.\n  Possible C/C++ prototypes are:\n    FIX::RegistTransType()\n    FIX::RegistTransType(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PaymentRemitterID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::PaymentRemitterID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PaymentRemitterID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PaymentRemitterID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PaymentRemitterID'.\n  Possible C/C++ prototypes are:\n    FIX::PaymentRemitterID()\n    FIX::PaymentRemitterID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriceType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::PriceType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriceType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PriceType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PriceType'.\n  Possible C/C++ prototypes are:\n    FIX::PriceType()\n    FIX::PriceType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarketReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::MarketReqID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarketReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MarketReqID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MarketReqID'.\n  Possible C/C++ prototypes are:\n    FIX::MarketReqID()\n    FIX::MarketReqID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNestedInstrAttrib__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoNestedInstrAttrib *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNestedInstrAttrib(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoNestedInstrAttrib__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoNestedInstrAttrib'.\n  Possible C/C++ prototypes are:\n    FIX::NoNestedInstrAttrib()\n    FIX::NoNestedInstrAttrib(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecuritySubType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SecuritySubType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecuritySubType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecuritySubType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecuritySubType'.\n  Possible C/C++ prototypes are:\n    FIX::SecuritySubType()\n    FIX::SecuritySubType(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClOrdID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ClOrdID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClOrdID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ClOrdID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ClOrdID'.\n  Possible C/C++ prototypes are:\n    FIX::ClOrdID()\n    FIX::ClOrdID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityDay__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DAYOFMONTH *arg1 = 0 ;
  FIX::MaturityDay *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityDay(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MaturityDay__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MaturityDay'.\n  Possible C/C++ prototypes are:\n    FIX::MaturityDay()\n    FIX::MaturityDay(FIX::DAYOFMONTH const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSeniority__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingSeniority *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSeniority(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingSeniority__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingSeniority'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingSeniority()\n    FIX::UnderlyingSeniority(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarketSegmentDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::MarketSegmentDesc *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarketSegmentDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MarketSegmentDesc__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MarketSegmentDesc'.\n  Possible C/C++ prototypes are:\n    FIX::MarketSegmentDesc()\n    FIX::MarketSegmentDesc(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoMarketSegments__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoMarketSegments *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoMarketSegments(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoMarketSegments__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoMarketSegments'.\n  Possible C/C++ prototypes are:\n    FIX::NoMarketSegments()\n    FIX::NoMarketSegments(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlObligMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::SettlObligMode *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlObligMode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlObligMode__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlObligMode'.\n  Possible C/C++ prototypes are:\n    FIX::SettlObligMode()\n    FIX::SettlObligMode(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityUpdateAction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::SecurityUpdateAction *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityUpdateAction(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecurityUpdateAction__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecurityUpdateAction'.\n  Possible C/C++ prototypes are:\n    FIX::SecurityUpdateAction()\n    FIX::SecurityUpdateAction(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetworkRequestType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::NetworkRequestType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetworkRequestType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NetworkRequestType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NetworkRequestType'.\n  Possible C/C++ prototypes are:\n    FIX::NetworkRequestType()\n    FIX::NetworkRequestType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LiquidityPctLow__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::LiquidityPctLow *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LiquidityPctLow(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LiquidityPctLow__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LiquidityPctLow'.\n  Possible C/C++ prototypes are:\n    FIX::LiquidityPctLow()\n    FIX::LiquidityPctLow(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PartyRole__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::PartyRole *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PartyRole(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PartyRole__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PartyRole'.\n  Possible C/C++ prototypes are:\n    FIX::PartyRole()\n    FIX::PartyRole(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegRatioQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::LegRatioQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegRatioQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegRatioQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegRatioQty'.\n  Possible C/C++ prototypes are:\n    FIX::LegRatioQty()\n    FIX::LegRatioQty(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlCurrFxRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::SettlCurrFxRate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlCurrFxRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlCurrFxRate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlCurrFxRate'.\n  Possible C/C++ prototypes are:\n    FIX::SettlCurrFxRate()\n    FIX::SettlCurrFxRate(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelatedPartyRole__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelatedPartyRole *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelatedPartyRole")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelatedPartyRole *)new FIX::RelatedPartyRole();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelatedPartyRole, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RelatedPartyRole(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelatedPartyRole__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelatedPartyRole__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelatedPartyRole'.\n  Possible C/C++ prototypes are:\n    FIX::RelatedPartyRole()\n    FIX::RelatedPartyRole(FIX::INT const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelatedPartyRole_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelatedPartyRole, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegContractMultiplierUnit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::LegContractMultiplierUnit *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegContractMultiplierUnit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegContractMultiplierUnit__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegContractMultiplierUnit'.\n  Possible C/C++ prototypes are:\n    FIX::LegContractMultiplierUnit()\n    FIX::LegContractMultiplierUnit(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecureData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  FIX::SecureData *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecureData(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecureData__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecureData'.\n  Possible C/C++ prototypes are:\n    FIX::SecureData()\n    FIX::SecureData(FIX::DATA const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SenderLocationID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SenderLocationID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SenderLocationID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SenderLocationID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SenderLocationID'.\n  Possible C/C++ prototypes are:\n    FIX::SenderLocationID()\n    FIX::SenderLocationID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FirstPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::FirstPx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FirstPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_FirstPx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_FirstPx'.\n  Possible C/C++ prototypes are:\n    FIX::FirstPx()\n    FIX::FirstPx(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedLegIssuer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  FIX::EncodedLegIssuer *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedLegIssuer(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncodedLegIssuer__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncodedLegIssuer'.\n  Possible C/C++ prototypes are:\n    FIX::EncodedLegIssuer()\n    FIX::EncodedLegIssuer(FIX::DATA const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AssignmentMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::AssignmentMethod *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AssignmentMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AssignmentMethod__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AssignmentMethod'.\n  Possible C/C++ prototypes are:\n    FIX::AssignmentMethod()\n    FIX::AssignmentMethod(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RoutingID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::RoutingID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RoutingID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RoutingID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RoutingID'.\n  Possible C/C++ prototypes are:\n    FIX::RoutingID()\n    FIX::RoutingID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelationshipRiskSecurityAltID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelationshipRiskSecurityAltID *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelationshipRiskSecurityAltID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskSecurityAltID *)new FIX::RelationshipRiskSecurityAltID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskSecurityAltID, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RelationshipRiskSecurityAltID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelationshipRiskSecurityAltID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelationshipRiskSecurityAltID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelationshipRiskSecurityAltID'.\n  Possible C/C++ prototypes are:\n    FIX::RelationshipRiskSecurityAltID()\n    FIX::RelationshipRiskSecurityAltID(FIX::STRING const &)\n");
  return NULL;
}


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


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

SWIGINTERN PyObject *_wrap_new_RelatedPartyAltID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelatedPartyAltID *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelatedPartyAltID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelatedPartyAltID *)new FIX::RelatedPartyAltID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelatedPartyAltID, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RelatedPartyAltID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelatedPartyAltID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelatedPartyAltID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelatedPartyAltID'.\n  Possible C/C++ prototypes are:\n    FIX::RelatedPartyAltID()\n    FIX::RelatedPartyAltID(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelatedPartyAltID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelatedPartyAltID, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrategyParameterType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::StrategyParameterType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrategyParameterType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StrategyParameterType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StrategyParameterType'.\n  Possible C/C++ prototypes are:\n    FIX::StrategyParameterType()\n    FIX::StrategyParameterType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncryptMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::EncryptMethod *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncryptMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncryptMethod__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncryptMethod'.\n  Possible C/C++ prototypes are:\n    FIX::EncryptMethod()\n    FIX::EncryptMethod(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingStateOrProvinceOfIssue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingStateOrProvinceOfIssue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingStateOrProvinceOfIssue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingStateOrProvinceOfIssue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingStateOrProvinceOfIssue'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingStateOrProvinceOfIssue()\n    FIX::UnderlyingStateOrProvinceOfIssue(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplNewSeqNum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SEQNUM *arg1 = 0 ;
  FIX::ApplNewSeqNum *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplNewSeqNum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ApplNewSeqNum__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ApplNewSeqNum'.\n  Possible C/C++ prototypes are:\n    FIX::ApplNewSeqNum()\n    FIX::ApplNewSeqNum(FIX::SEQNUM const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEncodedSecurityDescLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  FIX::DerivativeEncodedSecurityDescLen *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEncodedSecurityDescLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeEncodedSecurityDescLen__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeEncodedSecurityDescLen'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeEncodedSecurityDescLen()\n    FIX::DerivativeEncodedSecurityDescLen(FIX::LENGTH const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradingCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  FIX::TradingCurrency *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradingCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradingCurrency__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradingCurrency'.\n  Possible C/C++ prototypes are:\n    FIX::TradingCurrency()\n    FIX::TradingCurrency(FIX::CURRENCY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryHighLimitPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::SecondaryHighLimitPrice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryHighLimitPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecondaryHighLimitPrice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecondaryHighLimitPrice'.\n  Possible C/C++ prototypes are:\n    FIX::SecondaryHighLimitPrice()\n    FIX::SecondaryHighLimitPrice(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderAvgPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::OrderAvgPx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderAvgPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OrderAvgPx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OrderAvgPx'.\n  Possible C/C++ prototypes are:\n    FIX::OrderAvgPx()\n    FIX::OrderAvgPx(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosAmtType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::PosAmtType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosAmtType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PosAmtType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PosAmtType'.\n  Possible C/C++ prototypes are:\n    FIX::PosAmtType()\n    FIX::PosAmtType(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ResetSeqNumFlag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::ResetSeqNumFlag *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ResetSeqNumFlag(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ResetSeqNumFlag__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ResetSeqNumFlag'.\n  Possible C/C++ prototypes are:\n    FIX::ResetSeqNumFlag()\n    FIX::ResetSeqNumFlag(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoHops__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoHops *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoHops(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoHops__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoHops'.\n  Possible C/C++ prototypes are:\n    FIX::NoHops()\n    FIX::NoHops(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollInquiryResult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::CollInquiryResult *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollInquiryResult(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CollInquiryResult__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CollInquiryResult'.\n  Possible C/C++ prototypes are:\n    FIX::CollInquiryResult()\n    FIX::CollInquiryResult(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StartDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::StartDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StartDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StartDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StartDate'.\n  Possible C/C++ prototypes are:\n    FIX::StartDate()\n    FIX::StartDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollAsgnRespType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::CollAsgnRespType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollAsgnRespType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CollAsgnRespType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CollAsgnRespType'.\n  Possible C/C++ prototypes are:\n    FIX::CollAsgnRespType()\n    FIX::CollAsgnRespType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderBookingQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::OrderBookingQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderBookingQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OrderBookingQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OrderBookingQty'.\n  Possible C/C++ prototypes are:\n    FIX::OrderBookingQty()\n    FIX::OrderBookingQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoQuoteQualifiers__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoQuoteQualifiers *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoQuoteQualifiers(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoQuoteQualifiers__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoQuoteQualifiers'.\n  Possible C/C++ prototypes are:\n    FIX::NoQuoteQualifiers()\n    FIX::NoQuoteQualifiers(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnsolicitedIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::UnsolicitedIndicator *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnsolicitedIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnsolicitedIndicator__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnsolicitedIndicator'.\n  Possible C/C++ prototypes are:\n    FIX::UnsolicitedIndicator()\n    FIX::UnsolicitedIndicator(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefCstmApplVerID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::RefCstmApplVerID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefCstmApplVerID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RefCstmApplVerID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RefCstmApplVerID'.\n  Possible C/C++ prototypes are:\n    FIX::RefCstmApplVerID()\n    FIX::RefCstmApplVerID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideExecID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SideExecID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideExecID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SideExecID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SideExecID'.\n  Possible C/C++ prototypes are:\n    FIX::SideExecID()\n    FIX::SideExecID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RejectText__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::RejectText *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RejectText(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RejectText__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RejectText'.\n  Possible C/C++ prototypes are:\n    FIX::RejectText()\n    FIX::RejectText(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExchangeSpecialInstructions__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ExchangeSpecialInstructions *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExchangeSpecialInstructions(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ExchangeSpecialInstructions__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ExchangeSpecialInstructions'.\n  Possible C/C++ prototypes are:\n    FIX::ExchangeSpecialInstructions()\n    FIX::ExchangeSpecialInstructions(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::TradeID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradeID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradeID'.\n  Possible C/C++ prototypes are:\n    FIX::TradeID()\n    FIX::TradeID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RndPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::RndPx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RndPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RndPx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RndPx'.\n  Possible C/C++ prototypes are:\n    FIX::RndPx()\n    FIX::RndPx(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteEntryRejectReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::QuoteEntryRejectReason *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteEntryRejectReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_QuoteEntryRejectReason__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_QuoteEntryRejectReason'.\n  Possible C/C++ prototypes are:\n    FIX::QuoteEntryRejectReason()\n    FIX::QuoteEntryRejectReason(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderCapacity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::OrderCapacity *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderCapacity(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OrderCapacity__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OrderCapacity'.\n  Possible C/C++ prototypes are:\n    FIX::OrderCapacity()\n    FIX::OrderCapacity(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideLastQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::SideLastQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideLastQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SideLastQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SideLastQty'.\n  Possible C/C++ prototypes are:\n    FIX::SideLastQty()\n    FIX::SideLastQty(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeUnitOfMeasure__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DerivativeUnitOfMeasure *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeUnitOfMeasure(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeUnitOfMeasure__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeUnitOfMeasure'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeUnitOfMeasure()\n    FIX::DerivativeUnitOfMeasure(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoLegAllocs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoLegAllocs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoLegAllocs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoLegAllocs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoLegAllocs'.\n  Possible C/C++ prototypes are:\n    FIX::NoLegAllocs()\n    FIX::NoLegAllocs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteAckStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::QuoteAckStatus *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteAckStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_QuoteAckStatus__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_QuoteAckStatus'.\n  Possible C/C++ prototypes are:\n    FIX::QuoteAckStatus()\n    FIX::QuoteAckStatus(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryFirmTradeID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SecondaryFirmTradeID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryFirmTradeID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecondaryFirmTradeID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecondaryFirmTradeID'.\n  Possible C/C++ prototypes are:\n    FIX::SecondaryFirmTradeID()\n    FIX::SecondaryFirmTradeID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UserRequestType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::UserRequestType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UserRequestType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UserRequestType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UserRequestType'.\n  Possible C/C++ prototypes are:\n    FIX::UserRequestType()\n    FIX::UserRequestType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryTrdType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::SecondaryTrdType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryTrdType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecondaryTrdType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecondaryTrdType'.\n  Possible C/C++ prototypes are:\n    FIX::SecondaryTrdType()\n    FIX::SecondaryTrdType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeReportTransType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TradeReportTransType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeReportTransType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradeReportTransType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradeReportTransType'.\n  Possible C/C++ prototypes are:\n    FIX::TradeReportTransType()\n    FIX::TradeReportTransType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AdvSide__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::AdvSide *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AdvSide(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AdvSide__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AdvSide'.\n  Possible C/C++ prototypes are:\n    FIX::AdvSide()\n    FIX::AdvSide(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelatedContextPartySubID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelatedContextPartySubID *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelatedContextPartySubID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelatedContextPartySubID *)new FIX::RelatedContextPartySubID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelatedContextPartySubID, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RelatedContextPartySubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelatedContextPartySubID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelatedContextPartySubID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelatedContextPartySubID'.\n  Possible C/C++ prototypes are:\n    FIX::RelatedContextPartySubID()\n    FIX::RelatedContextPartySubID(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelatedContextPartySubID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelatedContextPartySubID, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecuritySubType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DerivativeSecuritySubType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecuritySubType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeSecuritySubType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeSecuritySubType'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeSecuritySubType()\n    FIX::DerivativeSecuritySubType(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerTradingSessionSubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::TriggerTradingSessionSubID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerTradingSessionSubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TriggerTradingSessionSubID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TriggerTradingSessionSubID'.\n  Possible C/C++ prototypes are:\n    FIX::TriggerTradingSessionSubID()\n    FIX::TriggerTradingSessionSubID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeLinkID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::TradeLinkID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeLinkID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradeLinkID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradeLinkID'.\n  Possible C/C++ prototypes are:\n    FIX::TradeLinkID()\n    FIX::TradeLinkID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegBenchmarkPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::LegBenchmarkPrice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegBenchmarkPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegBenchmarkPrice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegBenchmarkPrice'.\n  Possible C/C++ prototypes are:\n    FIX::LegBenchmarkPrice()\n    FIX::LegBenchmarkPrice(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HopRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SEQNUM *arg1 = 0 ;
  FIX::HopRefID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HopRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_HopRefID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_HopRefID'.\n  Possible C/C++ prototypes are:\n    FIX::HopRefID()\n    FIX::HopRefID(FIX::SEQNUM const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Designation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::Designation *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Designation(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Designation__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Designation'.\n  Possible C/C++ prototypes are:\n    FIX::Designation()\n    FIX::Designation(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeRequestID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::TradeRequestID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeRequestID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradeRequestID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradeRequestID'.\n  Possible C/C++ prototypes are:\n    FIX::TradeRequestID()\n    FIX::TradeRequestID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelationshipRiskLimitType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelationshipRiskLimitType *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelationshipRiskLimitType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskLimitType *)new FIX::RelationshipRiskLimitType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskLimitType, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RelationshipRiskLimitType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelationshipRiskLimitType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelationshipRiskLimitType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelationshipRiskLimitType'.\n  Possible C/C++ prototypes are:\n    FIX::RelationshipRiskLimitType()\n    FIX::RelationshipRiskLimitType(FIX::INT const &)\n");
  return NULL;
}


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


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

SWIGINTERN PyObject *_wrap_new_RiskSecurityIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskSecurityIDSource *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RiskSecurityIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskSecurityIDSource *)new FIX::RiskSecurityIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskSecurityIDSource, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RiskSecurityIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RiskSecurityIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskSecurityIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskSecurityIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::RiskSecurityIDSource()\n    FIX::RiskSecurityIDSource(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RiskSecurityIDSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RiskSecurityIDSource, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegFlowScheduleType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::LegFlowScheduleType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegFlowScheduleType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegFlowScheduleType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegFlowScheduleType'.\n  Possible C/C++ prototypes are:\n    FIX::LegFlowScheduleType()\n    FIX::LegFlowScheduleType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegPriceUnitOfMeasure__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LegPriceUnitOfMeasure *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegPriceUnitOfMeasure(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegPriceUnitOfMeasure__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegPriceUnitOfMeasure'.\n  Possible C/C++ prototypes are:\n    FIX::LegPriceUnitOfMeasure()\n    FIX::LegPriceUnitOfMeasure(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested4PartyIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::Nested4PartyIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested4PartyIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Nested4PartyIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Nested4PartyIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::Nested4PartyIDSource()\n    FIX::Nested4PartyIDSource(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CoveredOrUncovered__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::CoveredOrUncovered *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CoveredOrUncovered(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CoveredOrUncovered__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CoveredOrUncovered'.\n  Possible C/C++ prototypes are:\n    FIX::CoveredOrUncovered()\n    FIX::CoveredOrUncovered(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AcctIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::AcctIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AcctIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AcctIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AcctIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::AcctIDSource()\n    FIX::AcctIDSource(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MktOfferPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::MktOfferPx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MktOfferPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MktOfferPx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MktOfferPx'.\n  Possible C/C++ prototypes are:\n    FIX::MktOfferPx()\n    FIX::MktOfferPx(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoCapacities__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoCapacities *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoCapacities(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoCapacities__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoCapacities'.\n  Possible C/C++ prototypes are:\n    FIX::NoCapacities()\n    FIX::NoCapacities(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeRequestType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TradeRequestType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeRequestType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradeRequestType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradeRequestType'.\n  Possible C/C++ prototypes are:\n    FIX::TradeRequestType()\n    FIX::TradeRequestType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNestedPartyIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoNestedPartyIDs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNestedPartyIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoNestedPartyIDs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoNestedPartyIDs'.\n  Possible C/C++ prototypes are:\n    FIX::NoNestedPartyIDs()\n    FIX::NoNestedPartyIDs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TradSesStatus *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradSesStatus__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradSesStatus'.\n  Possible C/C++ prototypes are:\n    FIX::TradSesStatus()\n    FIX::TradSesStatus(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingNotionalPercentageOutstanding__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::UnderlyingNotionalPercentageOutstanding *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingNotionalPercentageOutstanding(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingNotionalPercentageOutstanding__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingNotionalPercentageOutstanding'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingNotionalPercentageOutstanding()\n    FIX::UnderlyingNotionalPercentageOutstanding(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplLastSeqNum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SEQNUM *arg1 = 0 ;
  FIX::ApplLastSeqNum *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplLastSeqNum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ApplLastSeqNum__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ApplLastSeqNum'.\n  Possible C/C++ prototypes are:\n    FIX::ApplLastSeqNum()\n    FIX::ApplLastSeqNum(FIX::SEQNUM const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegPriceType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::PegPriceType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegPriceType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PegPriceType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PegPriceType'.\n  Possible C/C++ prototypes are:\n    FIX::PegPriceType()\n    FIX::PegPriceType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrategyParameterName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::StrategyParameterName *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrategyParameterName(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StrategyParameterName__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StrategyParameterName'.\n  Possible C/C++ prototypes are:\n    FIX::StrategyParameterName()\n    FIX::StrategyParameterName(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StreamAsgnRejReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::StreamAsgnRejReason *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StreamAsgnRejReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StreamAsgnRejReason__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StreamAsgnRejReason'.\n  Possible C/C++ prototypes are:\n    FIX::StreamAsgnRejReason()\n    FIX::StreamAsgnRejReason(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MatchIncrement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::MatchIncrement *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MatchIncrement(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MatchIncrement__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MatchIncrement'.\n  Possible C/C++ prototypes are:\n    FIX::MatchIncrement()\n    FIX::MatchIncrement(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested3PartyRole__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::Nested3PartyRole *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested3PartyRole(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Nested3PartyRole__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Nested3PartyRole'.\n  Possible C/C++ prototypes are:\n    FIX::Nested3PartyRole()\n    FIX::Nested3PartyRole(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::UnderlyingPx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingPx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingPx'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingPx()\n    FIX::UnderlyingPx(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriceImprovement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  FIX::PriceImprovement *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriceImprovement(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PriceImprovement__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PriceImprovement'.\n  Possible C/C++ prototypes are:\n    FIX::PriceImprovement()\n    FIX::PriceImprovement(FIX::PRICEOFFSET const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ValuationMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ValuationMethod *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ValuationMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ValuationMethod__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ValuationMethod'.\n  Possible C/C++ prototypes are:\n    FIX::ValuationMethod()\n    FIX::ValuationMethod(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DerivativeSecurityID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeSecurityID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeSecurityID'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeSecurityID()\n    FIX::DerivativeSecurityID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoExpiration__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoExpiration *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoExpiration(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoExpiration__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoExpiration'.\n  Possible C/C++ prototypes are:\n    FIX::NoExpiration()\n    FIX::NoExpiration(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetCompID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::TargetCompID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetCompID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TargetCompID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TargetCompID'.\n  Possible C/C++ prototypes are:\n    FIX::TargetCompID()\n    FIX::TargetCompID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryBuyer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::MDEntryBuyer *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryBuyer(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MDEntryBuyer__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MDEntryBuyer'.\n  Possible C/C++ prototypes are:\n    FIX::MDEntryBuyer()\n    FIX::MDEntryBuyer(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelationshipRiskCouponRate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelationshipRiskCouponRate *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelationshipRiskCouponRate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskCouponRate *)new FIX::RelationshipRiskCouponRate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskCouponRate, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelationshipRiskCouponRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::RelationshipRiskCouponRate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_RelationshipRiskCouponRate",&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_RelationshipRiskCouponRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RelationshipRiskCouponRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskCouponRate *)new FIX::RelationshipRiskCouponRate((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskCouponRate, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelationshipRiskCouponRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelationshipRiskCouponRate__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelationshipRiskCouponRate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelationshipRiskCouponRate'.\n  Possible C/C++ prototypes are:\n    FIX::RelationshipRiskCouponRate()\n    FIX::RelationshipRiskCouponRate(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelationshipRiskCouponRate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelationshipRiskCouponRate, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoDerivativeInstrumentPartySubIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoDerivativeInstrumentPartySubIDs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoDerivativeInstrumentPartySubIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoDerivativeInstrumentPartySubIDs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoDerivativeInstrumentPartySubIDs'.\n  Possible C/C++ prototypes are:\n    FIX::NoDerivativeInstrumentPartySubIDs()\n    FIX::NoDerivativeInstrumentPartySubIDs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoMaturityRules__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoMaturityRules *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoMaturityRules(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoMaturityRules__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoMaturityRules'.\n  Possible C/C++ prototypes are:\n    FIX::NoMaturityRules()\n    FIX::NoMaturityRules(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteMsgID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::QuoteMsgID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteMsgID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_QuoteMsgID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_QuoteMsgID'.\n  Possible C/C++ prototypes are:\n    FIX::QuoteMsgID()\n    FIX::QuoteMsgID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::TriggerType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TriggerType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TriggerType'.\n  Possible C/C++ prototypes are:\n    FIX::TriggerType()\n    FIX::TriggerType(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriceProtectionScope__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::PriceProtectionScope *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriceProtectionScope(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PriceProtectionScope__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PriceProtectionScope'.\n  Possible C/C++ prototypes are:\n    FIX::PriceProtectionScope()\n    FIX::PriceProtectionScope(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNumAssignmentReports__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TotNumAssignmentReports *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNumAssignmentReports(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TotNumAssignmentReports__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TotNumAssignmentReports'.\n  Possible C/C++ prototypes are:\n    FIX::TotNumAssignmentReports()\n    FIX::TotNumAssignmentReports(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContraLegRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ContraLegRefID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContraLegRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ContraLegRefID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ContraLegRefID'.\n  Possible C/C++ prototypes are:\n    FIX::ContraLegRefID()\n    FIX::ContraLegRefID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeReportRejectReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TradeReportRejectReason *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeReportRejectReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradeReportRejectReason__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradeReportRejectReason'.\n  Possible C/C++ prototypes are:\n    FIX::TradeReportRejectReason()\n    FIX::TradeReportRejectReason(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeReportRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::TradeReportRefID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeReportRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradeReportRefID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradeReportRefID'.\n  Possible C/C++ prototypes are:\n    FIX::TradeReportRefID()\n    FIX::TradeReportRefID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityListType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::SecurityListType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityListType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecurityListType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecurityListType'.\n  Possible C/C++ prototypes are:\n    FIX::SecurityListType()\n    FIX::SecurityListType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DerivativeSecurityIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeSecurityIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeSecurityIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeSecurityIDSource()\n    FIX::DerivativeSecurityIDSource(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AssignmentUnit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::AssignmentUnit *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AssignmentUnit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AssignmentUnit__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AssignmentUnit'.\n  Possible C/C++ prototypes are:\n    FIX::AssignmentUnit()\n    FIX::AssignmentUnit(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeReportID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::TradeReportID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeReportID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradeReportID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradeReportID'.\n  Possible C/C++ prototypes are:\n    FIX::TradeReportID()\n    FIX::TradeReportID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRpts__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::NoRpts *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRpts(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoRpts__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoRpts'.\n  Possible C/C++ prototypes are:\n    FIX::NoRpts()\n    FIX::NoRpts(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegBenchmarkPriceType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::LegBenchmarkPriceType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegBenchmarkPriceType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegBenchmarkPriceType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegBenchmarkPriceType'.\n  Possible C/C++ prototypes are:\n    FIX::LegBenchmarkPriceType()\n    FIX::LegBenchmarkPriceType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedSubjectLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  FIX::EncodedSubjectLen *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedSubjectLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncodedSubjectLen__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncodedSubjectLen'.\n  Possible C/C++ prototypes are:\n    FIX::EncodedSubjectLen()\n    FIX::EncodedSubjectLen(FIX::LENGTH const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityXML__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::XMLDATA *arg1 = 0 ;
  FIX::SecurityXML *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityXML(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecurityXML__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecurityXML'.\n  Possible C/C++ prototypes are:\n    FIX::SecurityXML()\n    FIX::SecurityXML(FIX::XMLDATA const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegReportID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LegReportID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegReportID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegReportID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegReportID'.\n  Possible C/C++ prototypes are:\n    FIX::LegReportID()\n    FIX::LegReportID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested3PartySubIDType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::Nested3PartySubIDType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested3PartySubIDType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Nested3PartySubIDType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Nested3PartySubIDType'.\n  Possible C/C++ prototypes are:\n    FIX::Nested3PartySubIDType()\n    FIX::Nested3PartySubIDType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BenchmarkSecurityIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::BenchmarkSecurityIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BenchmarkSecurityIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_BenchmarkSecurityIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BenchmarkSecurityIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::BenchmarkSecurityIDSource()\n    FIX::BenchmarkSecurityIDSource(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteRejectReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::QuoteRejectReason *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteRejectReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_QuoteRejectReason__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_QuoteRejectReason'.\n  Possible C/C++ prototypes are:\n    FIX::QuoteRejectReason()\n    FIX::QuoteRejectReason(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HeartBtInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::HeartBtInt *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HeartBtInt(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_HeartBtInt__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_HeartBtInt'.\n  Possible C/C++ prototypes are:\n    FIX::HeartBtInt()\n    FIX::HeartBtInt(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidForwardPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  FIX::BidForwardPoints *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidForwardPoints(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_BidForwardPoints__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BidForwardPoints'.\n  Possible C/C++ prototypes are:\n    FIX::BidForwardPoints()\n    FIX::BidForwardPoints(FIX::PRICEOFFSET const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PossResend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::PossResend *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PossResend(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PossResend__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PossResend'.\n  Possible C/C++ prototypes are:\n    FIX::PossResend()\n    FIX::PossResend(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Symbol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::Symbol *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Symbol(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Symbol__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Symbol'.\n  Possible C/C++ prototypes are:\n    FIX::Symbol()\n    FIX::Symbol(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedUnderlyingSecurityDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  FIX::EncodedUnderlyingSecurityDesc *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedUnderlyingSecurityDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncodedUnderlyingSecurityDesc__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncodedUnderlyingSecurityDesc'.\n  Possible C/C++ prototypes are:\n    FIX::EncodedUnderlyingSecurityDesc()\n    FIX::EncodedUnderlyingSecurityDesc(FIX::DATA const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelatedPartyAltSubIDType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelatedPartyAltSubIDType *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelatedPartyAltSubIDType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelatedPartyAltSubIDType *)new FIX::RelatedPartyAltSubIDType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelatedPartyAltSubIDType, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RelatedPartyAltSubIDType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelatedPartyAltSubIDType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelatedPartyAltSubIDType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelatedPartyAltSubIDType'.\n  Possible C/C++ prototypes are:\n    FIX::RelatedPartyAltSubIDType()\n    FIX::RelatedPartyAltSubIDType(FIX::INT const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelatedPartyAltSubIDType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelatedPartyAltSubIDType, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarketReportID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::MarketReportID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarketReportID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MarketReportID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MarketReportID'.\n  Possible C/C++ prototypes are:\n    FIX::MarketReportID()\n    FIX::MarketReportID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::DiscretionPrice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DiscretionPrice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DiscretionPrice'.\n  Possible C/C++ prototypes are:\n    FIX::DiscretionPrice()\n    FIX::DiscretionPrice(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContAmtValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::ContAmtValue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContAmtValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ContAmtValue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ContAmtValue'.\n  Possible C/C++ prototypes are:\n    FIX::ContAmtValue()\n    FIX::ContAmtValue(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuantityType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::QuantityType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuantityType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_QuantityType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_QuantityType'.\n  Possible C/C++ prototypes are:\n    FIX::QuantityType()\n    FIX::QuantityType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventPriceBoundaryMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ComplexEventPriceBoundaryMethod *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventPriceBoundaryMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ComplexEventPriceBoundaryMethod__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ComplexEventPriceBoundaryMethod'.\n  Possible C/C++ prototypes are:\n    FIX::ComplexEventPriceBoundaryMethod()\n    FIX::ComplexEventPriceBoundaryMethod(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ImpliedMarketIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ImpliedMarketIndicator *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ImpliedMarketIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ImpliedMarketIndicator__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ImpliedMarketIndicator'.\n  Possible C/C++ prototypes are:\n    FIX::ImpliedMarketIndicator()\n    FIX::ImpliedMarketIndicator(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocClearingFeeIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::AllocClearingFeeIndicator *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocClearingFeeIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllocClearingFeeIndicator__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllocClearingFeeIndicator'.\n  Possible C/C++ prototypes are:\n    FIX::AllocClearingFeeIndicator()\n    FIX::AllocClearingFeeIndicator(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteRequestType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::QuoteRequestType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteRequestType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_QuoteRequestType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_QuoteRequestType'.\n  Possible C/C++ prototypes are:\n    FIX::QuoteRequestType()\n    FIX::QuoteRequestType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityRequestResult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::SecurityRequestResult *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityRequestResult(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecurityRequestResult__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecurityRequestResult'.\n  Possible C/C++ prototypes are:\n    FIX::SecurityRequestResult()\n    FIX::SecurityRequestResult(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderRestrictions__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MULTIPLECHARVALUE *arg1 = 0 ;
  FIX::OrderRestrictions *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderRestrictions(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OrderRestrictions__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OrderRestrictions'.\n  Possible C/C++ prototypes are:\n    FIX::OrderRestrictions()\n    FIX::OrderRestrictions(FIX::MULTIPLECHARVALUE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSideTrdRegTS__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoSideTrdRegTS *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSideTrdRegTS(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoSideTrdRegTS__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoSideTrdRegTS'.\n  Possible C/C++ prototypes are:\n    FIX::NoSideTrdRegTS()\n    FIX::NoSideTrdRegTS(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Text__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::Text *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Text(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Text__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Text'.\n  Possible C/C++ prototypes are:\n    FIX::Text()\n    FIX::Text(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedTextLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  FIX::EncodedTextLen *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedTextLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncodedTextLen__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncodedTextLen'.\n  Possible C/C++ prototypes are:\n    FIX::EncodedTextLen()\n    FIX::EncodedTextLen(FIX::LENGTH const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListExecInstType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::ListExecInstType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListExecInstType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ListExecInstType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ListExecInstType'.\n  Possible C/C++ prototypes are:\n    FIX::ListExecInstType()\n    FIX::ListExecInstType(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryOrderID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SecondaryOrderID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryOrderID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecondaryOrderID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecondaryOrderID'.\n  Possible C/C++ prototypes are:\n    FIX::SecondaryOrderID()\n    FIX::SecondaryOrderID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecBroker__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ExecBroker *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecBroker(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ExecBroker__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ExecBroker'.\n  Possible C/C++ prototypes are:\n    FIX::ExecBroker()\n    FIX::ExecBroker(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelationshipRiskEncodedSecurityDescLen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelationshipRiskEncodedSecurityDescLen *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelationshipRiskEncodedSecurityDescLen")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskEncodedSecurityDescLen *)new FIX::RelationshipRiskEncodedSecurityDescLen();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskEncodedSecurityDescLen, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelationshipRiskEncodedSecurityDescLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  FIX::RelationshipRiskEncodedSecurityDescLen *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_RelationshipRiskEncodedSecurityDescLen",&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_RelationshipRiskEncodedSecurityDescLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RelationshipRiskEncodedSecurityDescLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskEncodedSecurityDescLen *)new FIX::RelationshipRiskEncodedSecurityDescLen((FIX::LENGTH const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskEncodedSecurityDescLen, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelationshipRiskEncodedSecurityDescLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelationshipRiskEncodedSecurityDescLen__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelationshipRiskEncodedSecurityDescLen__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelationshipRiskEncodedSecurityDescLen'.\n  Possible C/C++ prototypes are:\n    FIX::RelationshipRiskEncodedSecurityDescLen()\n    FIX::RelationshipRiskEncodedSecurityDescLen(FIX::LENGTH const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelationshipRiskEncodedSecurityDescLen_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelationshipRiskEncodedSecurityDescLen, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityXMLLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  FIX::SecurityXMLLen *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityXMLLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecurityXMLLen__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecurityXMLLen'.\n  Possible C/C++ prototypes are:\n    FIX::SecurityXMLLen()\n    FIX::SecurityXMLLen(FIX::LENGTH const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplSeqNum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SEQNUM *arg1 = 0 ;
  FIX::ApplSeqNum *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplSeqNum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ApplSeqNum__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ApplSeqNum'.\n  Possible C/C++ prototypes are:\n    FIX::ApplSeqNum()\n    FIX::ApplSeqNum(FIX::SEQNUM const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaxTradeVol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::MaxTradeVol *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaxTradeVol(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MaxTradeVol__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MaxTradeVol'.\n  Possible C/C++ prototypes are:\n    FIX::MaxTradeVol()\n    FIX::MaxTradeVol(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OfferSwapPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  FIX::OfferSwapPoints *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OfferSwapPoints(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OfferSwapPoints__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OfferSwapPoints'.\n  Possible C/C++ prototypes are:\n    FIX::OfferSwapPoints()\n    FIX::OfferSwapPoints(FIX::PRICEOFFSET const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlPartySubIDType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::SettlPartySubIDType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlPartySubIDType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlPartySubIDType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlPartySubIDType'.\n  Possible C/C++ prototypes are:\n    FIX::SettlPartySubIDType()\n    FIX::SettlPartySubIDType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DistribPaymentMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::DistribPaymentMethod *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DistribPaymentMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DistribPaymentMethod__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DistribPaymentMethod'.\n  Possible C/C++ prototypes are:\n    FIX::DistribPaymentMethod()\n    FIX::DistribPaymentMethod(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalAffectedOrders__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TotalAffectedOrders *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalAffectedOrders(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TotalAffectedOrders__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TotalAffectedOrders'.\n  Possible C/C++ prototypes are:\n    FIX::TotalAffectedOrders()\n    FIX::TotalAffectedOrders(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikeIncrement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::StrikeIncrement *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikeIncrement(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StrikeIncrement__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StrikeIncrement'.\n  Possible C/C++ prototypes are:\n    FIX::StrikeIncrement()\n    FIX::StrikeIncrement(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderHandlingInstSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::OrderHandlingInstSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderHandlingInstSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OrderHandlingInstSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OrderHandlingInstSource'.\n  Possible C/C++ prototypes are:\n    FIX::OrderHandlingInstSource()\n    FIX::OrderHandlingInstSource(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CopyMsgIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::CopyMsgIndicator *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CopyMsgIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CopyMsgIndicator__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CopyMsgIndicator'.\n  Possible C/C++ prototypes are:\n    FIX::CopyMsgIndicator()\n    FIX::CopyMsgIndicator(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoDlvyInst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoDlvyInst *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoDlvyInst(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoDlvyInst__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoDlvyInst'.\n  Possible C/C++ prototypes are:\n    FIX::NoDlvyInst()\n    FIX::NoDlvyInst(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteEntryID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::QuoteEntryID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteEntryID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_QuoteEntryID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_QuoteEntryID'.\n  Possible C/C++ prototypes are:\n    FIX::QuoteEntryID()\n    FIX::QuoteEntryID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AffirmStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::AffirmStatus *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AffirmStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AffirmStatus__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AffirmStatus'.\n  Possible C/C++ prototypes are:\n    FIX::AffirmStatus()\n    FIX::AffirmStatus(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MailingInst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::MailingInst *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MailingInst(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MailingInst__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MailingInst'.\n  Possible C/C++ prototypes are:\n    FIX::MailingInst()\n    FIX::MailingInst(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OfferSize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::OfferSize *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OfferSize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OfferSize__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OfferSize'.\n  Possible C/C++ prototypes are:\n    FIX::OfferSize()\n    FIX::OfferSize(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSecurityType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LegSecurityType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSecurityType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegSecurityType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegSecurityType'.\n  Possible C/C++ prototypes are:\n    FIX::LegSecurityType()\n    FIX::LegSecurityType(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RiskLimitPlatform__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskLimitPlatform *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RiskLimitPlatform")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskLimitPlatform *)new FIX::RiskLimitPlatform();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskLimitPlatform, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RiskLimitPlatform(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RiskLimitPlatform__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskLimitPlatform__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskLimitPlatform'.\n  Possible C/C++ prototypes are:\n    FIX::RiskLimitPlatform()\n    FIX::RiskLimitPlatform(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RiskLimitPlatform_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RiskLimitPlatform, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigCustOrderCapacity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::OrigCustOrderCapacity *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigCustOrderCapacity(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OrigCustOrderCapacity__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OrigCustOrderCapacity'.\n  Possible C/C++ prototypes are:\n    FIX::OrigCustOrderCapacity()\n    FIX::OrigCustOrderCapacity(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::AllocMethod *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllocMethod__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllocMethod'.\n  Possible C/C++ prototypes are:\n    FIX::AllocMethod()\n    FIX::AllocMethod(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuantityDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::QuantityDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuantityDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_QuantityDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_QuantityDate'.\n  Possible C/C++ prototypes are:\n    FIX::QuantityDate()\n    FIX::QuantityDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetStrategyPerformance__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::TargetStrategyPerformance *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetStrategyPerformance(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TargetStrategyPerformance__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TargetStrategyPerformance'.\n  Possible C/C++ prototypes are:\n    FIX::TargetStrategyPerformance()\n    FIX::TargetStrategyPerformance(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CardExpDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::CardExpDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CardExpDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CardExpDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CardExpDate'.\n  Possible C/C++ prototypes are:\n    FIX::CardExpDate()\n    FIX::CardExpDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfirmID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ConfirmID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfirmID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ConfirmID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ConfirmID'.\n  Possible C/C++ prototypes are:\n    FIX::ConfirmID()\n    FIX::ConfirmID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StandInstDbName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::StandInstDbName *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StandInstDbName(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StandInstDbName__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StandInstDbName'.\n  Possible C/C++ prototypes are:\n    FIX::StandInstDbName()\n    FIX::StandInstDbName(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DayOrderQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::DayOrderQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DayOrderQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DayOrderQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DayOrderQty'.\n  Possible C/C++ prototypes are:\n    FIX::DayOrderQty()\n    FIX::DayOrderQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HighLimitPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::HighLimitPrice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HighLimitPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_HighLimitPrice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_HighLimitPrice'.\n  Possible C/C++ prototypes are:\n    FIX::HighLimitPrice()\n    FIX::HighLimitPrice(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FirmTradeID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::FirmTradeID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FirmTradeID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_FirmTradeID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_FirmTradeID'.\n  Possible C/C++ prototypes are:\n    FIX::FirmTradeID()\n    FIX::FirmTradeID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryIndividualAllocID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SecondaryIndividualAllocID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryIndividualAllocID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecondaryIndividualAllocID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecondaryIndividualAllocID'.\n  Possible C/C++ prototypes are:\n    FIX::SecondaryIndividualAllocID()\n    FIX::SecondaryIndividualAllocID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AgreementDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::AgreementDesc *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AgreementDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AgreementDesc__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AgreementDesc'.\n  Possible C/C++ prototypes are:\n    FIX::AgreementDesc()\n    FIX::AgreementDesc(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassCancelResponse__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::MassCancelResponse *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassCancelResponse(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MassCancelResponse__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MassCancelResponse'.\n  Possible C/C++ prototypes are:\n    FIX::MassCancelResponse()\n    FIX::MassCancelResponse(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSettlCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  FIX::LegSettlCurrency *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSettlCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegSettlCurrency__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegSettlCurrency'.\n  Possible C/C++ prototypes are:\n    FIX::LegSettlCurrency()\n    FIX::LegSettlCurrency(FIX::CURRENCY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Commission__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::Commission *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Commission(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Commission__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Commission'.\n  Possible C/C++ prototypes are:\n    FIX::Commission()\n    FIX::Commission(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StreamAsgnReqType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::StreamAsgnReqType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StreamAsgnReqType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StreamAsgnReqType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StreamAsgnReqType'.\n  Possible C/C++ prototypes are:\n    FIX::StreamAsgnReqType()\n    FIX::StreamAsgnReqType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidSwapPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  FIX::BidSwapPoints *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidSwapPoints(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_BidSwapPoints__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BidSwapPoints'.\n  Possible C/C++ prototypes are:\n    FIX::BidSwapPoints()\n    FIX::BidSwapPoints(FIX::PRICEOFFSET const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSettlPartyIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoSettlPartyIDs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSettlPartyIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoSettlPartyIDs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoSettlPartyIDs'.\n  Possible C/C++ prototypes are:\n    FIX::NoSettlPartyIDs()\n    FIX::NoSettlPartyIDs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SymbolSfx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SymbolSfx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SymbolSfx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SymbolSfx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SymbolSfx'.\n  Possible C/C++ prototypes are:\n    FIX::SymbolSfx()\n    FIX::SymbolSfx(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BusinessRejectRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::BusinessRejectRefID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BusinessRejectRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_BusinessRejectRefID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BusinessRejectRefID'.\n  Possible C/C++ prototypes are:\n    FIX::BusinessRejectRefID()\n    FIX::BusinessRejectRefID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Price2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::Price2 *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Price2(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Price2__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Price2'.\n  Possible C/C++ prototypes are:\n    FIX::Price2()\n    FIX::Price2(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FillLiquidityInd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::FillLiquidityInd *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FillLiquidityInd(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_FillLiquidityInd__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_FillLiquidityInd'.\n  Possible C/C++ prototypes are:\n    FIX::FillLiquidityInd()\n    FIX::FillLiquidityInd(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassActionReportID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::MassActionReportID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassActionReportID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MassActionReportID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MassActionReportID'.\n  Possible C/C++ prototypes are:\n    FIX::MassActionReportID()\n    FIX::MassActionReportID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeIssuer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DerivativeIssuer *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeIssuer(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeIssuer__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeIssuer'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeIssuer()\n    FIX::DerivativeIssuer(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExDestinationIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::ExDestinationIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExDestinationIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ExDestinationIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ExDestinationIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::ExDestinationIDSource()\n    FIX::ExDestinationIDSource(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollRespID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::CollRespID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollRespID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CollRespID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CollRespID'.\n  Possible C/C++ prototypes are:\n    FIX::CollRespID()\n    FIX::CollRespID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityListRequestType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::SecurityListRequestType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityListRequestType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecurityListRequestType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecurityListRequestType'.\n  Possible C/C++ prototypes are:\n    FIX::SecurityListRequestType()\n    FIX::SecurityListRequestType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedLegSecurityDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  FIX::EncodedLegSecurityDesc *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedLegSecurityDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncodedLegSecurityDesc__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncodedLegSecurityDesc'.\n  Possible C/C++ prototypes are:\n    FIX::EncodedLegSecurityDesc()\n    FIX::EncodedLegSecurityDesc(FIX::DATA const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelatedContextPartyRole__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelatedContextPartyRole *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelatedContextPartyRole")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelatedContextPartyRole *)new FIX::RelatedContextPartyRole();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelatedContextPartyRole, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RelatedContextPartyRole(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelatedContextPartyRole__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelatedContextPartyRole__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelatedContextPartyRole'.\n  Possible C/C++ prototypes are:\n    FIX::RelatedContextPartyRole()\n    FIX::RelatedContextPartyRole(FIX::INT const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelatedContextPartyRole_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelatedContextPartyRole, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSettlementStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingSettlementStatus *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSettlementStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingSettlementStatus__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingSettlementStatus'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingSettlementStatus()\n    FIX::UnderlyingSettlementStatus(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityAltID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SecurityAltID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityAltID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecurityAltID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecurityAltID'.\n  Possible C/C++ prototypes are:\n    FIX::SecurityAltID()\n    FIX::SecurityAltID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::RegistRefID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RegistRefID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RegistRefID'.\n  Possible C/C++ prototypes are:\n    FIX::RegistRefID()\n    FIX::RegistRefID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelationshipRiskFlexibleIndicator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelationshipRiskFlexibleIndicator *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelationshipRiskFlexibleIndicator")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskFlexibleIndicator *)new FIX::RelationshipRiskFlexibleIndicator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskFlexibleIndicator, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelationshipRiskFlexibleIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::RelationshipRiskFlexibleIndicator *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_RelationshipRiskFlexibleIndicator",&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_RelationshipRiskFlexibleIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RelationshipRiskFlexibleIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskFlexibleIndicator *)new FIX::RelationshipRiskFlexibleIndicator((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskFlexibleIndicator, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelationshipRiskFlexibleIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelationshipRiskFlexibleIndicator__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelationshipRiskFlexibleIndicator__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelationshipRiskFlexibleIndicator'.\n  Possible C/C++ prototypes are:\n    FIX::RelationshipRiskFlexibleIndicator()\n    FIX::RelationshipRiskFlexibleIndicator(FIX::BOOLEAN const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelationshipRiskFlexibleIndicator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelationshipRiskFlexibleIndicator, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativePriceQuoteMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DerivativePriceQuoteMethod *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativePriceQuoteMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativePriceQuoteMethod__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativePriceQuoteMethod'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativePriceQuoteMethod()\n    FIX::DerivativePriceQuoteMethod(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelationshipRiskProductComplex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelationshipRiskProductComplex *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelationshipRiskProductComplex")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskProductComplex *)new FIX::RelationshipRiskProductComplex();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskProductComplex, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RelationshipRiskProductComplex(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelationshipRiskProductComplex__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelationshipRiskProductComplex__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelationshipRiskProductComplex'.\n  Possible C/C++ prototypes are:\n    FIX::RelationshipRiskProductComplex()\n    FIX::RelationshipRiskProductComplex(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelationshipRiskProductComplex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelationshipRiskProductComplex, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderDelay__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::OrderDelay *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderDelay(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OrderDelay__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OrderDelay'.\n  Possible C/C++ prototypes are:\n    FIX::OrderDelay()\n    FIX::OrderDelay(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNotAffectedOrders__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoNotAffectedOrders *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNotAffectedOrders(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoNotAffectedOrders__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoNotAffectedOrders'.\n  Possible C/C++ prototypes are:\n    FIX::NoNotAffectedOrders()\n    FIX::NoNotAffectedOrders(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested3PartyID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::Nested3PartyID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested3PartyID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Nested3PartyID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Nested3PartyID'.\n  Possible C/C++ prototypes are:\n    FIX::Nested3PartyID()\n    FIX::Nested3PartyID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollAsgnReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::CollAsgnReason *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollAsgnReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CollAsgnReason__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CollAsgnReason'.\n  Possible C/C++ prototypes are:\n    FIX::CollAsgnReason()\n    FIX::CollAsgnReason(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalVolumeTradedTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMEONLY *arg1 = 0 ;
  FIX::TotalVolumeTradedTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalVolumeTradedTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TotalVolumeTradedTime__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TotalVolumeTradedTime'.\n  Possible C/C++ prototypes are:\n    FIX::TotalVolumeTradedTime()\n    FIX::TotalVolumeTradedTime(FIX::UTCTIMEONLY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityExchange__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EXCHANGE *arg1 = 0 ;
  FIX::SecurityExchange *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityExchange(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecurityExchange__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecurityExchange'.\n  Possible C/C++ prototypes are:\n    FIX::SecurityExchange()\n    FIX::SecurityExchange(FIX::EXCHANGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlPriceType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::SettlPriceType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlPriceType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlPriceType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlPriceType'.\n  Possible C/C++ prototypes are:\n    FIX::SettlPriceType()\n    FIX::SettlPriceType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnitOfMeasureQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::UnitOfMeasureQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnitOfMeasureQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnitOfMeasureQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnitOfMeasureQty'.\n  Possible C/C++ prototypes are:\n    FIX::UnitOfMeasureQty()\n    FIX::UnitOfMeasureQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UserRequestID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UserRequestID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UserRequestID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UserRequestID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UserRequestID'.\n  Possible C/C++ prototypes are:\n    FIX::UserRequestID()\n    FIX::UserRequestID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastParPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::LastParPx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastParPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LastParPx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LastParPx'.\n  Possible C/C++ prototypes are:\n    FIX::LastParPx()\n    FIX::LastParPx(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EndMaturityMonthYear__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MONTHYEAR *arg1 = 0 ;
  FIX::EndMaturityMonthYear *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EndMaturityMonthYear(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EndMaturityMonthYear__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EndMaturityMonthYear'.\n  Possible C/C++ prototypes are:\n    FIX::EndMaturityMonthYear()\n    FIX::EndMaturityMonthYear(FIX::MONTHYEAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DealingCapacity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::DealingCapacity *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DealingCapacity(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DealingCapacity__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DealingCapacity'.\n  Possible C/C++ prototypes are:\n    FIX::DealingCapacity()\n    FIX::DealingCapacity(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PrevClosePx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::PrevClosePx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PrevClosePx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PrevClosePx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PrevClosePx'.\n  Possible C/C++ prototypes are:\n    FIX::PrevClosePx()\n    FIX::PrevClosePx(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeInputDevice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::TradeInputDevice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeInputDevice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradeInputDevice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradeInputDevice'.\n  Possible C/C++ prototypes are:\n    FIX::TradeInputDevice()\n    FIX::TradeInputDevice(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DayCumQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::DayCumQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DayCumQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DayCumQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DayCumQty'.\n  Possible C/C++ prototypes are:\n    FIX::DayCumQty()\n    FIX::DayCumQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecuritySettlAgentAcctNum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SecuritySettlAgentAcctNum *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecuritySettlAgentAcctNum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecuritySettlAgentAcctNum__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecuritySettlAgentAcctNum'.\n  Possible C/C++ prototypes are:\n    FIX::SecuritySettlAgentAcctNum()\n    FIX::SecuritySettlAgentAcctNum(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  FIX::LegCurrency *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegCurrency__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegCurrency'.\n  Possible C/C++ prototypes are:\n    FIX::LegCurrency()\n    FIX::LegCurrency(FIX::CURRENCY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncryptedNewPassword__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  FIX::EncryptedNewPassword *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncryptedNewPassword(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncryptedNewPassword__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncryptedNewPassword'.\n  Possible C/C++ prototypes are:\n    FIX::EncryptedNewPassword()\n    FIX::EncryptedNewPassword(FIX::DATA const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeMinPriceIncrementAmount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::DerivativeMinPriceIncrementAmount *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeMinPriceIncrementAmount(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeMinPriceIncrementAmount__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeMinPriceIncrementAmount'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeMinPriceIncrementAmount()\n    FIX::DerivativeMinPriceIncrementAmount(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNested3PartySubIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoNested3PartySubIDs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNested3PartySubIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoNested3PartySubIDs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoNested3PartySubIDs'.\n  Possible C/C++ prototypes are:\n    FIX::NoNested3PartySubIDs()\n    FIX::NoNested3PartySubIDs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefSubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::RefSubID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefSubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RefSubID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RefSubID'.\n  Possible C/C++ prototypes are:\n    FIX::RefSubID()\n    FIX::RefSubID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlPartyRole__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::SettlPartyRole *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlPartyRole(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlPartyRole__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlPartyRole'.\n  Possible C/C++ prototypes are:\n    FIX::SettlPartyRole()\n    FIX::SettlPartyRole(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashDistribAgentName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::CashDistribAgentName *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashDistribAgentName(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CashDistribAgentName__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CashDistribAgentName'.\n  Possible C/C++ prototypes are:\n    FIX::CashDistribAgentName()\n    FIX::CashDistribAgentName(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegContractMultiplier__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::LegContractMultiplier *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegContractMultiplier(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegContractMultiplier__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegContractMultiplier'.\n  Possible C/C++ prototypes are:\n    FIX::LegContractMultiplier()\n    FIX::LegContractMultiplier(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ProgPeriodInterval__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ProgPeriodInterval *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ProgPeriodInterval(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ProgPeriodInterval__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ProgPeriodInterval'.\n  Possible C/C++ prototypes are:\n    FIX::ProgPeriodInterval()\n    FIX::ProgPeriodInterval(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSettlType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::LegSettlType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSettlType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegSettlType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegSettlType'.\n  Possible C/C++ prototypes are:\n    FIX::LegSettlType()\n    FIX::LegSettlType(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OnBehalfOfLocationID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::OnBehalfOfLocationID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OnBehalfOfLocationID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OnBehalfOfLocationID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OnBehalfOfLocationID'.\n  Possible C/C++ prototypes are:\n    FIX::OnBehalfOfLocationID()\n    FIX::OnBehalfOfLocationID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OnBehalfOfSubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::OnBehalfOfSubID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OnBehalfOfSubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OnBehalfOfSubID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OnBehalfOfSubID'.\n  Possible C/C++ prototypes are:\n    FIX::OnBehalfOfSubID()\n    FIX::OnBehalfOfSubID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelationshipRiskLimitPlatform__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelationshipRiskLimitPlatform *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelationshipRiskLimitPlatform")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskLimitPlatform *)new FIX::RelationshipRiskLimitPlatform();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskLimitPlatform, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RelationshipRiskLimitPlatform(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelationshipRiskLimitPlatform__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelationshipRiskLimitPlatform__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelationshipRiskLimitPlatform'.\n  Possible C/C++ prototypes are:\n    FIX::RelationshipRiskLimitPlatform()\n    FIX::RelationshipRiskLimitPlatform(FIX::STRING const &)\n");
  return NULL;
}


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


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

SWIGINTERN PyObject *_wrap_new_RelatedPartySubID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelatedPartySubID *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelatedPartySubID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelatedPartySubID *)new FIX::RelatedPartySubID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelatedPartySubID, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RelatedPartySubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelatedPartySubID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelatedPartySubID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelatedPartySubID'.\n  Possible C/C++ prototypes are:\n    FIX::RelatedPartySubID()\n    FIX::RelatedPartySubID(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelatedPartySubID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelatedPartySubID, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventEndTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMEONLY *arg1 = 0 ;
  FIX::ComplexEventEndTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventEndTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ComplexEventEndTime__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ComplexEventEndTime'.\n  Possible C/C++ prototypes are:\n    FIX::ComplexEventEndTime()\n    FIX::ComplexEventEndTime(FIX::UTCTIMEONLY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RateSourceType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::RateSourceType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RateSourceType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RateSourceType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RateSourceType'.\n  Possible C/C++ prototypes are:\n    FIX::RateSourceType()\n    FIX::RateSourceType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeStateOrProvinceOfIssue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DerivativeStateOrProvinceOfIssue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeStateOrProvinceOfIssue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeStateOrProvinceOfIssue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeStateOrProvinceOfIssue'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeStateOrProvinceOfIssue()\n    FIX::DerivativeStateOrProvinceOfIssue(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeLegRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::TradeLegRefID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeLegRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradeLegRefID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradeLegRefID'.\n  Possible C/C++ prototypes are:\n    FIX::TradeLegRefID()\n    FIX::TradeLegRefID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelSymTransactTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  FIX::RelSymTransactTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelSymTransactTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  FIX::RelSymTransactTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelSymTransactTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  FIX::RelSymTransactTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelSymTransactTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_new_RelSymTransactTime__SWIG_3(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelSymTransactTime'.\n  Possible C/C++ prototypes are:\n    FIX::RelSymTransactTime()\n    FIX::RelSymTransactTime(bool)\n    FIX::RelSymTransactTime(FIX::UTCTIMESTAMP const &)\n    FIX::RelSymTransactTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoComplexEventTimes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoComplexEventTimes *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoComplexEventTimes(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoComplexEventTimes__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoComplexEventTimes'.\n  Possible C/C++ prototypes are:\n    FIX::NoComplexEventTimes()\n    FIX::NoComplexEventTimes(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCalculatedCcyLastQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::LegCalculatedCcyLastQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCalculatedCcyLastQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegCalculatedCcyLastQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegCalculatedCcyLastQty'.\n  Possible C/C++ prototypes are:\n    FIX::LegCalculatedCcyLastQty()\n    FIX::LegCalculatedCcyLastQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested3PartyIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::Nested3PartyIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested3PartyIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Nested3PartyIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Nested3PartyIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::Nested3PartyIDSource()\n    FIX::Nested3PartyIDSource(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatedDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::DatedDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatedDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DatedDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DatedDate'.\n  Possible C/C++ prototypes are:\n    FIX::DatedDate()\n    FIX::DatedDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SettlInstID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlInstID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlInstID'.\n  Possible C/C++ prototypes are:\n    FIX::SettlInstID()\n    FIX::SettlInstID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OpenInterest__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::OpenInterest *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OpenInterest(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OpenInterest__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OpenInterest'.\n  Possible C/C++ prototypes are:\n    FIX::OpenInterest()\n    FIX::OpenInterest(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingContractMultiplier__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::UnderlyingContractMultiplier *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingContractMultiplier(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingContractMultiplier__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingContractMultiplier'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingContractMultiplier()\n    FIX::UnderlyingContractMultiplier(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotQuoteEntries__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TotQuoteEntries *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotQuoteEntries(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TotQuoteEntries__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TotQuoteEntries'.\n  Possible C/C++ prototypes are:\n    FIX::TotQuoteEntries()\n    FIX::TotQuoteEntries(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_PartyAltSubID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PartyAltSubID *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_PartyAltSubID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PartyAltSubID *)new FIX::PartyAltSubID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PartyAltSubID, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_PartyAltSubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_PartyAltSubID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PartyAltSubID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PartyAltSubID'.\n  Possible C/C++ prototypes are:\n    FIX::PartyAltSubID()\n    FIX::PartyAltSubID(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *PartyAltSubID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PartyAltSubID, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoCxldQuotes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TotNoCxldQuotes *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoCxldQuotes(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TotNoCxldQuotes__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TotNoCxldQuotes'.\n  Possible C/C++ prototypes are:\n    FIX::TotNoCxldQuotes()\n    FIX::TotNoCxldQuotes(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AggregatedBook__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::AggregatedBook *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AggregatedBook(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AggregatedBook__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AggregatedBook'.\n  Possible C/C++ prototypes are:\n    FIX::AggregatedBook()\n    FIX::AggregatedBook(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PaymentRef__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::PaymentRef *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PaymentRef(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PaymentRef__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PaymentRef'.\n  Possible C/C++ prototypes are:\n    FIX::PaymentRef()\n    FIX::PaymentRef(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PaymentDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::PaymentDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PaymentDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PaymentDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PaymentDate'.\n  Possible C/C++ prototypes are:\n    FIX::PaymentDate()\n    FIX::PaymentDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderPercent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::OrderPercent *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderPercent(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OrderPercent__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OrderPercent'.\n  Possible C/C++ prototypes are:\n    FIX::OrderPercent()\n    FIX::OrderPercent(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosQtyStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::PosQtyStatus *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosQtyStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PosQtyStatus__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PosQtyStatus'.\n  Possible C/C++ prototypes are:\n    FIX::PosQtyStatus()\n    FIX::PosQtyStatus(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RiskRestructuringType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskRestructuringType *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RiskRestructuringType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskRestructuringType *)new FIX::RiskRestructuringType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskRestructuringType, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RiskRestructuringType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RiskRestructuringType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskRestructuringType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskRestructuringType'.\n  Possible C/C++ prototypes are:\n    FIX::RiskRestructuringType()\n    FIX::RiskRestructuringType(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RiskRestructuringType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RiskRestructuringType, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNested4PartySubIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoNested4PartySubIDs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNested4PartySubIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoNested4PartySubIDs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoNested4PartySubIDs'.\n  Possible C/C++ prototypes are:\n    FIX::NoNested4PartySubIDs()\n    FIX::NoNested4PartySubIDs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PrivateQuote__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::PrivateQuote *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PrivateQuote(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PrivateQuote__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PrivateQuote'.\n  Possible C/C++ prototypes are:\n    FIX::PrivateQuote()\n    FIX::PrivateQuote(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryTradeID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SecondaryTradeID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryTradeID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecondaryTradeID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecondaryTradeID'.\n  Possible C/C++ prototypes are:\n    FIX::SecondaryTradeID()\n    FIX::SecondaryTradeID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecuritySettlAgentContactPhone__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SecuritySettlAgentContactPhone *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecuritySettlAgentContactPhone(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecuritySettlAgentContactPhone__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecuritySettlAgentContactPhone'.\n  Possible C/C++ prototypes are:\n    FIX::SecuritySettlAgentContactPhone()\n    FIX::SecuritySettlAgentContactPhone(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedMktSegmDescLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  FIX::EncodedMktSegmDescLen *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedMktSegmDescLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncodedMktSegmDescLen__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncodedMktSegmDescLen'.\n  Possible C/C++ prototypes are:\n    FIX::EncodedMktSegmDescLen()\n    FIX::EncodedMktSegmDescLen(FIX::LENGTH const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  FIX::SideCurrency *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SideCurrency__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SideCurrency'.\n  Possible C/C++ prototypes are:\n    FIX::SideCurrency()\n    FIX::SideCurrency(FIX::CURRENCY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::LegQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegQty'.\n  Possible C/C++ prototypes are:\n    FIX::LegQty()\n    FIX::LegQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MsgType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::MsgType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MsgType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MsgType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MsgType'.\n  Possible C/C++ prototypes are:\n    FIX::MsgType()\n    FIX::MsgType(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTradingSessions__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoTradingSessions *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTradingSessions(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoTradingSessions__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoTradingSessions'.\n  Possible C/C++ prototypes are:\n    FIX::NoTradingSessions()\n    FIX::NoTradingSessions(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOIid__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::IOIid *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOIid(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_IOIid__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_IOIid'.\n  Possible C/C++ prototypes are:\n    FIX::IOIid()\n    FIX::IOIid(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MultiLegReportingType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::MultiLegReportingType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MultiLegReportingType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MultiLegReportingType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MultiLegReportingType'.\n  Possible C/C++ prototypes are:\n    FIX::MultiLegReportingType()\n    FIX::MultiLegReportingType(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::IDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_IDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_IDSource'.\n  Possible C/C++ prototypes are:\n    FIX::IDSource()\n    FIX::IDSource(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegStipulationType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LegStipulationType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegStipulationType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegStipulationType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegStipulationType'.\n  Possible C/C++ prototypes are:\n    FIX::LegStipulationType()\n    FIX::LegStipulationType(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeContractMultiplierUnit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::DerivativeContractMultiplierUnit *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeContractMultiplierUnit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeContractMultiplierUnit__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeContractMultiplierUnit'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeContractMultiplierUnit()\n    FIX::DerivativeContractMultiplierUnit(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarketSegmentID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::MarketSegmentID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarketSegmentID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MarketSegmentID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MarketSegmentID'.\n  Possible C/C++ prototypes are:\n    FIX::MarketSegmentID()\n    FIX::MarketSegmentID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrdStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::OrdStatus *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrdStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OrdStatus__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OrdStatus'.\n  Possible C/C++ prototypes are:\n    FIX::OrdStatus()\n    FIX::OrdStatus(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::MaturityDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MaturityDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MaturityDate'.\n  Possible C/C++ prototypes are:\n    FIX::MaturityDate()\n    FIX::MaturityDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplTotalMessageCount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ApplTotalMessageCount *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplTotalMessageCount(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ApplTotalMessageCount__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ApplTotalMessageCount'.\n  Possible C/C++ prototypes are:\n    FIX::ApplTotalMessageCount()\n    FIX::ApplTotalMessageCount(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrumentPartySubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::InstrumentPartySubID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrumentPartySubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_InstrumentPartySubID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_InstrumentPartySubID'.\n  Possible C/C++ prototypes are:\n    FIX::InstrumentPartySubID()\n    FIX::InstrumentPartySubID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CustomerOrFirm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::CustomerOrFirm *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CustomerOrFirm(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CustomerOrFirm__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CustomerOrFirm'.\n  Possible C/C++ prototypes are:\n    FIX::CustomerOrFirm()\n    FIX::CustomerOrFirm(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AdjustmentType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::AdjustmentType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AdjustmentType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AdjustmentType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AdjustmentType'.\n  Possible C/C++ prototypes are:\n    FIX::AdjustmentType()\n    FIX::AdjustmentType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_NoPartyAltSubIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoPartyAltSubIDs *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_NoPartyAltSubIDs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoPartyAltSubIDs *)new FIX::NoPartyAltSubIDs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoPartyAltSubIDs, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoPartyAltSubIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoPartyAltSubIDs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoPartyAltSubIDs",&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_NoPartyAltSubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoPartyAltSubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoPartyAltSubIDs *)new FIX::NoPartyAltSubIDs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoPartyAltSubIDs, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoPartyAltSubIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_NoPartyAltSubIDs__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoPartyAltSubIDs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoPartyAltSubIDs'.\n  Possible C/C++ prototypes are:\n    FIX::NoPartyAltSubIDs()\n    FIX::NoPartyAltSubIDs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *NoPartyAltSubIDs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoPartyAltSubIDs, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingInstrumentPartyID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingInstrumentPartyID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingInstrumentPartyID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingInstrumentPartyID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingInstrumentPartyID'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingInstrumentPartyID()\n    FIX::UnderlyingInstrumentPartyID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AsOfIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::AsOfIndicator *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AsOfIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AsOfIndicator__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AsOfIndicator'.\n  Possible C/C++ prototypes are:\n    FIX::AsOfIndicator()\n    FIX::AsOfIndicator(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteStatusReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::QuoteStatusReqID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteStatusReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_QuoteStatusReqID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_QuoteStatusReqID'.\n  Possible C/C++ prototypes are:\n    FIX::QuoteStatusReqID()\n    FIX::QuoteStatusReqID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegPositionEffect__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::LegPositionEffect *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegPositionEffect(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegPositionEffect__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegPositionEffect'.\n  Possible C/C++ prototypes are:\n    FIX::LegPositionEffect()\n    FIX::LegPositionEffect(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::MDEntryPx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MDEntryPx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MDEntryPx'.\n  Possible C/C++ prototypes are:\n    FIX::MDEntryPx()\n    FIX::MDEntryPx(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassActionScope__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::MassActionScope *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassActionScope(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MassActionScope__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MassActionScope'.\n  Possible C/C++ prototypes are:\n    FIX::MassActionScope()\n    FIX::MassActionScope(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ReportedPxDiff__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::ReportedPxDiff *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ReportedPxDiff(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ReportedPxDiff__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ReportedPxDiff'.\n  Possible C/C++ prototypes are:\n    FIX::ReportedPxDiff()\n    FIX::ReportedPxDiff(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSettlementDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::UnderlyingSettlementDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSettlementDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingSettlementDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingSettlementDate'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingSettlementDate()\n    FIX::UnderlyingSettlementDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNestedPartySubIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoNestedPartySubIDs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNestedPartySubIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoNestedPartySubIDs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoNestedPartySubIDs'.\n  Possible C/C++ prototypes are:\n    FIX::NoNestedPartySubIDs()\n    FIX::NoNestedPartySubIDs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocReportRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::AllocReportRefID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocReportRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllocReportRefID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllocReportRefID'.\n  Possible C/C++ prototypes are:\n    FIX::AllocReportRefID()\n    FIX::AllocReportRefID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Concession__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::Concession *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Concession(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Concession__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Concession'.\n  Possible C/C++ prototypes are:\n    FIX::Concession()\n    FIX::Concession(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedSecurityDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  FIX::EncodedSecurityDesc *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedSecurityDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncodedSecurityDesc__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncodedSecurityDesc'.\n  Possible C/C++ prototypes are:\n    FIX::EncodedSecurityDesc()\n    FIX::EncodedSecurityDesc(FIX::DATA const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ExecRefID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ExecRefID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ExecRefID'.\n  Possible C/C++ prototypes are:\n    FIX::ExecRefID()\n    FIX::ExecRefID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VenueType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::VenueType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VenueType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_VenueType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VenueType'.\n  Possible C/C++ prototypes are:\n    FIX::VenueType()\n    FIX::VenueType(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassActionType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::MassActionType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassActionType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MassActionType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MassActionType'.\n  Possible C/C++ prototypes are:\n    FIX::MassActionType()\n    FIX::MassActionType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosMaintResult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::PosMaintResult *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosMaintResult(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PosMaintResult__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PosMaintResult'.\n  Possible C/C++ prototypes are:\n    FIX::PosMaintResult()\n    FIX::PosMaintResult(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOIShares__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::IOIShares *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOIShares(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_IOIShares__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_IOIShares'.\n  Possible C/C++ prototypes are:\n    FIX::IOIShares()\n    FIX::IOIShares(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BenchmarkSecurityID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::BenchmarkSecurityID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BenchmarkSecurityID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_BenchmarkSecurityID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BenchmarkSecurityID'.\n  Possible C/C++ prototypes are:\n    FIX::BenchmarkSecurityID()\n    FIX::BenchmarkSecurityID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegLastQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::LegLastQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegLastQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegLastQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegLastQty'.\n  Possible C/C++ prototypes are:\n    FIX::LegLastQty()\n    FIX::LegLastQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocSettlCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  FIX::AllocSettlCurrency *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocSettlCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllocSettlCurrency__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllocSettlCurrency'.\n  Possible C/C++ prototypes are:\n    FIX::AllocSettlCurrency()\n    FIX::AllocSettlCurrency(FIX::CURRENCY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCountryOfIssue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::COUNTRY *arg1 = 0 ;
  FIX::LegCountryOfIssue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCountryOfIssue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegCountryOfIssue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegCountryOfIssue'.\n  Possible C/C++ prototypes are:\n    FIX::LegCountryOfIssue()\n    FIX::LegCountryOfIssue(FIX::COUNTRY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityXML__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  FIX::DerivativeSecurityXML *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityXML(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeSecurityXML__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeSecurityXML'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeSecurityXML()\n    FIX::DerivativeSecurityXML(FIX::DATA const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikeRuleID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::StrikeRuleID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikeRuleID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StrikeRuleID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StrikeRuleID'.\n  Possible C/C++ prototypes are:\n    FIX::StrikeRuleID()\n    FIX::StrikeRuleID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefCompID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::RefCompID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefCompID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RefCompID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RefCompID'.\n  Possible C/C++ prototypes are:\n    FIX::RefCompID()\n    FIX::RefCompID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlCurrOfferFxRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::SettlCurrOfferFxRate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlCurrOfferFxRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlCurrOfferFxRate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlCurrOfferFxRate'.\n  Possible C/C++ prototypes are:\n    FIX::SettlCurrOfferFxRate()\n    FIX::SettlCurrOfferFxRate(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OfferYield__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::OfferYield *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OfferYield(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OfferYield__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OfferYield'.\n  Possible C/C++ prototypes are:\n    FIX::OfferYield()\n    FIX::OfferYield(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelatedContextPartyID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelatedContextPartyID *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelatedContextPartyID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelatedContextPartyID *)new FIX::RelatedContextPartyID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelatedContextPartyID, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RelatedContextPartyID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelatedContextPartyID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelatedContextPartyID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelatedContextPartyID'.\n  Possible C/C++ prototypes are:\n    FIX::RelatedContextPartyID()\n    FIX::RelatedContextPartyID(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelatedContextPartyID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelatedContextPartyID, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetPartyIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::TargetPartyIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetPartyIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TargetPartyIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TargetPartyIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::TargetPartyIDSource()\n    FIX::TargetPartyIDSource(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncryptedNewPasswordLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  FIX::EncryptedNewPasswordLen *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncryptedNewPasswordLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncryptedNewPasswordLen__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncryptedNewPasswordLen'.\n  Possible C/C++ prototypes are:\n    FIX::EncryptedNewPasswordLen()\n    FIX::EncryptedNewPasswordLen(FIX::LENGTH const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoPositions__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoPositions *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoPositions(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoPositions__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoPositions'.\n  Possible C/C++ prototypes are:\n    FIX::NoPositions()\n    FIX::NoPositions(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalAccruedInterestAmt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::TotalAccruedInterestAmt *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalAccruedInterestAmt(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TotalAccruedInterestAmt__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TotalAccruedInterestAmt'.\n  Possible C/C++ prototypes are:\n    FIX::TotalAccruedInterestAmt()\n    FIX::TotalAccruedInterestAmt(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingOptAttribute__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::UnderlyingOptAttribute *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingOptAttribute(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingOptAttribute__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingOptAttribute'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingOptAttribute()\n    FIX::UnderlyingOptAttribute(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrAttribValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DerivativeInstrAttribValue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrAttribValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeInstrAttribValue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeInstrAttribValue'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeInstrAttribValue()\n    FIX::DerivativeInstrAttribValue(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrumentPartyIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::InstrumentPartyIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrumentPartyIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_InstrumentPartyIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_InstrumentPartyIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::InstrumentPartyIDSource()\n    FIX::InstrumentPartyIDSource(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegOffsetType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::PegOffsetType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegOffsetType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PegOffsetType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PegOffsetType'.\n  Possible C/C++ prototypes are:\n    FIX::PegOffsetType()\n    FIX::PegOffsetType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassCancelRejectReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::MassCancelRejectReason *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassCancelRejectReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MassCancelRejectReason__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MassCancelRejectReason'.\n  Possible C/C++ prototypes are:\n    FIX::MassCancelRejectReason()\n    FIX::MassCancelRejectReason(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ResponseTransportType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ResponseTransportType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ResponseTransportType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ResponseTransportType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ResponseTransportType'.\n  Possible C/C++ prototypes are:\n    FIX::ResponseTransportType()\n    FIX::ResponseTransportType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSecurityIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LegSecurityIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSecurityIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegSecurityIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegSecurityIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::LegSecurityIDSource()\n    FIX::LegSecurityIDSource(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BasisFeaturePrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::BasisFeaturePrice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BasisFeaturePrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_BasisFeaturePrice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BasisFeaturePrice'.\n  Possible C/C++ prototypes are:\n    FIX::BasisFeaturePrice()\n    FIX::BasisFeaturePrice(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CouponPaymentDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::CouponPaymentDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CouponPaymentDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CouponPaymentDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CouponPaymentDate'.\n  Possible C/C++ prototypes are:\n    FIX::CouponPaymentDate()\n    FIX::CouponPaymentDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesStatusRejReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TradSesStatusRejReason *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesStatusRejReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradSesStatusRejReason__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradSesStatusRejReason'.\n  Possible C/C++ prototypes are:\n    FIX::TradSesStatusRejReason()\n    FIX::TradSesStatusRejReason(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingDetachmentPoint__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::UnderlyingDetachmentPoint *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingDetachmentPoint(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingDetachmentPoint__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingDetachmentPoint'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingDetachmentPoint()\n    FIX::UnderlyingDetachmentPoint(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityRuleID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::MaturityRuleID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityRuleID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MaturityRuleID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MaturityRuleID'.\n  Possible C/C++ prototypes are:\n    FIX::MaturityRuleID()\n    FIX::MaturityRuleID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_UnderlyingRepoCollateralSecurityType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_UnderlyingRepoCollateralSecurityType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingRepoCollateralSecurityType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingRepoCollateralSecurityType'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingRepoCollateralSecurityType()\n    FIX::UnderlyingRepoCollateralSecurityType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTimeInForceRules__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoTimeInForceRules *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTimeInForceRules(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoTimeInForceRules__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoTimeInForceRules'.\n  Possible C/C++ prototypes are:\n    FIX::NoTimeInForceRules()\n    FIX::NoTimeInForceRules(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRootPartySubIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRootPartySubIDs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRootPartySubIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoRootPartySubIDs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoRootPartySubIDs'.\n  Possible C/C++ prototypes are:\n    FIX::NoRootPartySubIDs()\n    FIX::NoRootPartySubIDs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DisplayMinIncr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::DisplayMinIncr *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DisplayMinIncr(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DisplayMinIncr__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DisplayMinIncr'.\n  Possible C/C++ prototypes are:\n    FIX::DisplayMinIncr()\n    FIX::DisplayMinIncr(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdRegTimestampType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TrdRegTimestampType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdRegTimestampType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TrdRegTimestampType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TrdRegTimestampType'.\n  Possible C/C++ prototypes are:\n    FIX::TrdRegTimestampType()\n    FIX::TrdRegTimestampType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegProduct__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::LegProduct *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegProduct(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegProduct__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegProduct'.\n  Possible C/C++ prototypes are:\n    FIX::LegProduct()\n    FIX::LegProduct(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplVerID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ApplVerID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplVerID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ApplVerID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ApplVerID'.\n  Possible C/C++ prototypes are:\n    FIX::ApplVerID()\n    FIX::ApplVerID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HandlInst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::HandlInst *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HandlInst(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_HandlInst__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_HandlInst'.\n  Possible C/C++ prototypes are:\n    FIX::HandlInst()\n    FIX::HandlInst(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListUpdateAction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::ListUpdateAction *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListUpdateAction(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ListUpdateAction__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ListUpdateAction'.\n  Possible C/C++ prototypes are:\n    FIX::ListUpdateAction()\n    FIX::ListUpdateAction(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NestedInstrAttribValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::NestedInstrAttribValue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NestedInstrAttribValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NestedInstrAttribValue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NestedInstrAttribValue'.\n  Possible C/C++ prototypes are:\n    FIX::NestedInstrAttribValue()\n    FIX::NestedInstrAttribValue(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradingSessionSubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::TradingSessionSubID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradingSessionSubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradingSessionSubID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradingSessionSubID'.\n  Possible C/C++ prototypes are:\n    FIX::TradingSessionSubID()\n    FIX::TradingSessionSubID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RFQReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::RFQReqID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RFQReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RFQReqID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RFQReqID'.\n  Possible C/C++ prototypes are:\n    FIX::RFQReqID()\n    FIX::RFQReqID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelationshipRiskSecurityExchange__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelationshipRiskSecurityExchange *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelationshipRiskSecurityExchange")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskSecurityExchange *)new FIX::RelationshipRiskSecurityExchange();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskSecurityExchange, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelationshipRiskSecurityExchange__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EXCHANGE *arg1 = 0 ;
  FIX::RelationshipRiskSecurityExchange *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_RelationshipRiskSecurityExchange",&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_RelationshipRiskSecurityExchange" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RelationshipRiskSecurityExchange" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::EXCHANGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskSecurityExchange *)new FIX::RelationshipRiskSecurityExchange((FIX::EXCHANGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskSecurityExchange, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelationshipRiskSecurityExchange(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelationshipRiskSecurityExchange__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelationshipRiskSecurityExchange__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelationshipRiskSecurityExchange'.\n  Possible C/C++ prototypes are:\n    FIX::RelationshipRiskSecurityExchange()\n    FIX::RelationshipRiskSecurityExchange(FIX::EXCHANGE const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelationshipRiskSecurityExchange_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelationshipRiskSecurityExchange, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSymbolSfx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingLegSymbolSfx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSymbolSfx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingLegSymbolSfx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingLegSymbolSfx'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingLegSymbolSfx()\n    FIX::UnderlyingLegSymbolSfx(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LiquidityNumSecurities__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::LiquidityNumSecurities *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LiquidityNumSecurities(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LiquidityNumSecurities__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LiquidityNumSecurities'.\n  Possible C/C++ prototypes are:\n    FIX::LiquidityNumSecurities()\n    FIX::LiquidityNumSecurities(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoMsgTypes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoMsgTypes *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoMsgTypes(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoMsgTypes__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoMsgTypes'.\n  Possible C/C++ prototypes are:\n    FIX::NoMsgTypes()\n    FIX::NoMsgTypes(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesStartTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  FIX::TradSesStartTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesStartTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  FIX::TradSesStartTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesStartTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  FIX::TradSesStartTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesStartTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_new_TradSesStartTime__SWIG_3(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradSesStartTime'.\n  Possible C/C++ prototypes are:\n    FIX::TradSesStartTime()\n    FIX::TradSesStartTime(bool)\n    FIX::TradSesStartTime(FIX::UTCTIMESTAMP const &)\n    FIX::TradSesStartTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::MDEntryType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MDEntryType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MDEntryType'.\n  Possible C/C++ prototypes are:\n    FIX::MDEntryType()\n    FIX::MDEntryType(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AgreementCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  FIX::AgreementCurrency *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AgreementCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AgreementCurrency__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AgreementCurrency'.\n  Possible C/C++ prototypes are:\n    FIX::AgreementCurrency()\n    FIX::AgreementCurrency(FIX::CURRENCY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegMoveType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::PegMoveType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegMoveType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PegMoveType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PegMoveType'.\n  Possible C/C++ prototypes are:\n    FIX::PegMoveType()\n    FIX::PegMoveType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_AsgnReqID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AsgnReqID *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_AsgnReqID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AsgnReqID *)new FIX::AsgnReqID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AsgnReqID, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_AsgnReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_AsgnReqID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AsgnReqID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AsgnReqID'.\n  Possible C/C++ prototypes are:\n    FIX::AsgnReqID()\n    FIX::AsgnReqID(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *AsgnReqID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AsgnReqID, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegDifference__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  FIX::PegDifference *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegDifference(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PegDifference__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PegDifference'.\n  Possible C/C++ prototypes are:\n    FIX::PegDifference()\n    FIX::PegDifference(FIX::PRICEOFFSET const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Spread__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  FIX::Spread *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Spread(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Spread__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Spread'.\n  Possible C/C++ prototypes are:\n    FIX::Spread()\n    FIX::Spread(FIX::PRICEOFFSET const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedAllocTextLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  FIX::EncodedAllocTextLen *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedAllocTextLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncodedAllocTextLen__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncodedAllocTextLen'.\n  Possible C/C++ prototypes are:\n    FIX::EncodedAllocTextLen()\n    FIX::EncodedAllocTextLen(FIX::LENGTH const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OutsideIndexPct__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::OutsideIndexPct *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OutsideIndexPct(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OutsideIndexPct__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OutsideIndexPct'.\n  Possible C/C++ prototypes are:\n    FIX::OutsideIndexPct()\n    FIX::OutsideIndexPct(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivFlexProductEligibilityIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::DerivFlexProductEligibilityIndicator *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivFlexProductEligibilityIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivFlexProductEligibilityIndicator__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivFlexProductEligibilityIndicator'.\n  Possible C/C++ prototypes are:\n    FIX::DerivFlexProductEligibilityIndicator()\n    FIX::DerivFlexProductEligibilityIndicator(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AvgPxIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::AvgPxIndicator *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AvgPxIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AvgPxIndicator__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AvgPxIndicator'.\n  Possible C/C++ prototypes are:\n    FIX::AvgPxIndicator()\n    FIX::AvgPxIndicator(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoIOIQualifiers__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoIOIQualifiers *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoIOIQualifiers(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoIOIQualifiers__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoIOIQualifiers'.\n  Possible C/C++ prototypes are:\n    FIX::NoIOIQualifiers()\n    FIX::NoIOIQualifiers(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CancellationRights__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::CancellationRights *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CancellationRights(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CancellationRights__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CancellationRights'.\n  Possible C/C++ prototypes are:\n    FIX::CancellationRights()\n    FIX::CancellationRights(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListSeqNo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ListSeqNo *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListSeqNo(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ListSeqNo__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ListSeqNo'.\n  Possible C/C++ prototypes are:\n    FIX::ListSeqNo()\n    FIX::ListSeqNo(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CardIssNum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::CardIssNum *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CardIssNum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CardIssNum__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CardIssNum'.\n  Possible C/C++ prototypes are:\n    FIX::CardIssNum()\n    FIX::CardIssNum(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RiskCFICode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskCFICode *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RiskCFICode")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskCFICode *)new FIX::RiskCFICode();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskCFICode, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RiskCFICode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RiskCFICode__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskCFICode__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskCFICode'.\n  Possible C/C++ prototypes are:\n    FIX::RiskCFICode()\n    FIX::RiskCFICode(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RiskCFICode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RiskCFICode, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedMktSegmDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  FIX::EncodedMktSegmDesc *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedMktSegmDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncodedMktSegmDesc__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncodedMktSegmDesc'.\n  Possible C/C++ prototypes are:\n    FIX::EncodedMktSegmDesc()\n    FIX::EncodedMktSegmDesc(FIX::DATA const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEventType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::DerivativeEventType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEventType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeEventType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeEventType'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeEventType()\n    FIX::DerivativeEventType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeMaturityMonthYear__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MONTHYEAR *arg1 = 0 ;
  FIX::DerivativeMaturityMonthYear *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeMaturityMonthYear(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeMaturityMonthYear__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeMaturityMonthYear'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeMaturityMonthYear()\n    FIX::DerivativeMaturityMonthYear(FIX::MONTHYEAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideTradeReportID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SideTradeReportID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideTradeReportID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SideTradeReportID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SideTradeReportID'.\n  Possible C/C++ prototypes are:\n    FIX::SideTradeReportID()\n    FIX::SideTradeReportID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoQuoteSets__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoQuoteSets *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoQuoteSets(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoQuoteSets__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoQuoteSets'.\n  Possible C/C++ prototypes are:\n    FIX::NoQuoteSets()\n    FIX::NoQuoteSets(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelationshipRiskSecurityDesc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelationshipRiskSecurityDesc *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelationshipRiskSecurityDesc")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskSecurityDesc *)new FIX::RelationshipRiskSecurityDesc();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskSecurityDesc, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RelationshipRiskSecurityDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelationshipRiskSecurityDesc__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelationshipRiskSecurityDesc__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelationshipRiskSecurityDesc'.\n  Possible C/C++ prototypes are:\n    FIX::RelationshipRiskSecurityDesc()\n    FIX::RelationshipRiskSecurityDesc(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelationshipRiskSecurityDesc_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelationshipRiskSecurityDesc, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested4PartySubIDType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::Nested4PartySubIDType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested4PartySubIDType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Nested4PartySubIDType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Nested4PartySubIDType'.\n  Possible C/C++ prototypes are:\n    FIX::Nested4PartySubIDType()\n    FIX::Nested4PartySubIDType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FillPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::FillPx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FillPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_FillPx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_FillPx'.\n  Possible C/C++ prototypes are:\n    FIX::FillPx()\n    FIX::FillPx(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikeExerciseStyle__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::StrikeExerciseStyle *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikeExerciseStyle(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StrikeExerciseStyle__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StrikeExerciseStyle'.\n  Possible C/C++ prototypes are:\n    FIX::StrikeExerciseStyle()\n    FIX::StrikeExerciseStyle(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeskID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DeskID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeskID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DeskID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DeskID'.\n  Possible C/C++ prototypes are:\n    FIX::DeskID()\n    FIX::DeskID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CrossPercent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::CrossPercent *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CrossPercent(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CrossPercent__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CrossPercent'.\n  Possible C/C++ prototypes are:\n    FIX::CrossPercent()\n    FIX::CrossPercent(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityMonthYear__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MONTHYEAR *arg1 = 0 ;
  FIX::MaturityMonthYear *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityMonthYear(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MaturityMonthYear__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MaturityMonthYear'.\n  Possible C/C++ prototypes are:\n    FIX::MaturityMonthYear()\n    FIX::MaturityMonthYear(FIX::MONTHYEAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::ComplexEventPrice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ComplexEventPrice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ComplexEventPrice'.\n  Possible C/C++ prototypes are:\n    FIX::ComplexEventPrice()\n    FIX::ComplexEventPrice(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNewsRefIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoNewsRefIDs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNewsRefIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoNewsRefIDs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoNewsRefIDs'.\n  Possible C/C++ prototypes are:\n    FIX::NoNewsRefIDs()\n    FIX::NoNewsRefIDs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCapValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::UnderlyingCapValue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCapValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingCapValue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingCapValue'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingCapValue()\n    FIX::UnderlyingCapValue(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPRegType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::CPRegType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPRegType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CPRegType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CPRegType'.\n  Possible C/C++ prototypes are:\n    FIX::CPRegType()\n    FIX::CPRegType(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashDistribAgentCode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::CashDistribAgentCode *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashDistribAgentCode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CashDistribAgentCode__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CashDistribAgentCode'.\n  Possible C/C++ prototypes are:\n    FIX::CashDistribAgentCode()\n    FIX::CashDistribAgentCode(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecPriceType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::ExecPriceType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecPriceType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ExecPriceType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ExecPriceType'.\n  Possible C/C++ prototypes are:\n    FIX::ExecPriceType()\n    FIX::ExecPriceType(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegAllocID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LegAllocID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegAllocID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegAllocID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegAllocID'.\n  Possible C/C++ prototypes are:\n    FIX::LegAllocID()\n    FIX::LegAllocID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMEONLY *arg1 = 0 ;
  FIX::MDEntryTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MDEntryTime__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MDEntryTime'.\n  Possible C/C++ prototypes are:\n    FIX::MDEntryTime()\n    FIX::MDEntryTime(FIX::UTCTIMEONLY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalNumSecurities__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TotalNumSecurities *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalNumSecurities(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TotalNumSecurities__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TotalNumSecurities'.\n  Possible C/C++ prototypes are:\n    FIX::TotalNumSecurities()\n    FIX::TotalNumSecurities(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocSettlInstType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::AllocSettlInstType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocSettlInstType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllocSettlInstType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllocSettlInstType'.\n  Possible C/C++ prototypes are:\n    FIX::AllocSettlInstType()\n    FIX::AllocSettlInstType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetPartyID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::TargetPartyID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetPartyID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TargetPartyID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TargetPartyID'.\n  Possible C/C++ prototypes are:\n    FIX::TargetPartyID()\n    FIX::TargetPartyID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeStrikeCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  FIX::DerivativeStrikeCurrency *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeStrikeCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeStrikeCurrency__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeStrikeCurrency'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeStrikeCurrency()\n    FIX::DerivativeStrikeCurrency(FIX::CURRENCY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StatsType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::StatsType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StatsType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StatsType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StatsType'.\n  Possible C/C++ prototypes are:\n    FIX::StatsType()\n    FIX::StatsType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplExtID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ApplExtID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplExtID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ApplExtID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ApplExtID'.\n  Possible C/C++ prototypes are:\n    FIX::ApplExtID()\n    FIX::ApplExtID(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlementCycleNo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::SettlementCycleNo *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlementCycleNo(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlementCycleNo__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlementCycleNo'.\n  Possible C/C++ prototypes are:\n    FIX::SettlementCycleNo()\n    FIX::SettlementCycleNo(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingStrikeCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  FIX::UnderlyingStrikeCurrency *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingStrikeCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingStrikeCurrency__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingStrikeCurrency'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingStrikeCurrency()\n    FIX::UnderlyingStrikeCurrency(FIX::CURRENCY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TradSesMode *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesMode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradSesMode__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradSesMode'.\n  Possible C/C++ prototypes are:\n    FIX::TradSesMode()\n    FIX::TradSesMode(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::SettlInstSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlInstSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlInstSource'.\n  Possible C/C++ prototypes are:\n    FIX::SettlInstSource()\n    FIX::SettlInstSource(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_PartyAltSubIDType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PartyAltSubIDType *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_PartyAltSubIDType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PartyAltSubIDType *)new FIX::PartyAltSubIDType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PartyAltSubIDType, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_PartyAltSubIDType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_PartyAltSubIDType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PartyAltSubIDType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PartyAltSubIDType'.\n  Possible C/C++ prototypes are:\n    FIX::PartyAltSubIDType()\n    FIX::PartyAltSubIDType(FIX::INT const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *PartyAltSubIDType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PartyAltSubIDType, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingLegSecurityDesc *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingLegSecurityDesc__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingLegSecurityDesc'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingLegSecurityDesc()\n    FIX::UnderlyingLegSecurityDesc(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoDerivativeInstrumentParties__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoDerivativeInstrumentParties *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoDerivativeInstrumentParties(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoDerivativeInstrumentParties__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoDerivativeInstrumentParties'.\n  Possible C/C++ prototypes are:\n    FIX::NoDerivativeInstrumentParties()\n    FIX::NoDerivativeInstrumentParties(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEventTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  FIX::DerivativeEventTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEventTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  FIX::DerivativeEventTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEventTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  FIX::DerivativeEventTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEventTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_new_DerivativeEventTime__SWIG_3(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeEventTime'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeEventTime()\n    FIX::DerivativeEventTime(bool)\n    FIX::DerivativeEventTime(FIX::UTCTIMESTAMP const &)\n    FIX::DerivativeEventTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TickIncrement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::TickIncrement *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TickIncrement(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TickIncrement__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TickIncrement'.\n  Possible C/C++ prototypes are:\n    FIX::TickIncrement()\n    FIX::TickIncrement(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndlyInstrumentPartyID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UndlyInstrumentPartyID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndlyInstrumentPartyID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UndlyInstrumentPartyID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UndlyInstrumentPartyID'.\n  Possible C/C++ prototypes are:\n    FIX::UndlyInstrumentPartyID()\n    FIX::UndlyInstrumentPartyID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoUndlyInstrumentParties__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoUndlyInstrumentParties *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoUndlyInstrumentParties(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoUndlyInstrumentParties__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoUndlyInstrumentParties'.\n  Possible C/C++ prototypes are:\n    FIX::NoUndlyInstrumentParties()\n    FIX::NoUndlyInstrumentParties(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExpType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ExpType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExpType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ExpType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ExpType'.\n  Possible C/C++ prototypes are:\n    FIX::ExpType()\n    FIX::ExpType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryClOrdID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SecondaryClOrdID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryClOrdID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecondaryClOrdID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecondaryClOrdID'.\n  Possible C/C++ prototypes are:\n    FIX::SecondaryClOrdID()\n    FIX::SecondaryClOrdID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstTransType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::SettlInstTransType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstTransType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlInstTransType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlInstTransType'.\n  Possible C/C++ prototypes are:\n    FIX::SettlInstTransType()\n    FIX::SettlInstTransType(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideComplianceID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SideComplianceID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideComplianceID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SideComplianceID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SideComplianceID'.\n  Possible C/C++ prototypes are:\n    FIX::SideComplianceID()\n    FIX::SideComplianceID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeRequestResult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TradeRequestResult *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeRequestResult(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradeRequestResult__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradeRequestResult'.\n  Possible C/C++ prototypes are:\n    FIX::TradeRequestResult()\n    FIX::TradeRequestResult(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigPosReqRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::OrigPosReqRefID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigPosReqRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OrigPosReqRefID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OrigPosReqRefID'.\n  Possible C/C++ prototypes are:\n    FIX::OrigPosReqRefID()\n    FIX::OrigPosReqRefID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigCrossID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::OrigCrossID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigCrossID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OrigCrossID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OrigCrossID'.\n  Possible C/C++ prototypes are:\n    FIX::OrigCrossID()\n    FIX::OrigCrossID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeInputSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::TradeInputSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeInputSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradeInputSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradeInputSource'.\n  Possible C/C++ prototypes are:\n    FIX::TradeInputSource()\n    FIX::TradeInputSource(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderQty2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::OrderQty2 *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderQty2(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OrderQty2__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OrderQty2'.\n  Possible C/C++ prototypes are:\n    FIX::OrderQty2()\n    FIX::OrderQty2(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TestMessageIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::TestMessageIndicator *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TestMessageIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TestMessageIndicator__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TestMessageIndicator'.\n  Possible C/C++ prototypes are:\n    FIX::TestMessageIndicator()\n    FIX::TestMessageIndicator(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_ContextPartySubID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContextPartySubID *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_ContextPartySubID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContextPartySubID *)new FIX::ContextPartySubID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContextPartySubID, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_ContextPartySubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_ContextPartySubID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ContextPartySubID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ContextPartySubID'.\n  Possible C/C++ prototypes are:\n    FIX::ContextPartySubID()\n    FIX::ContextPartySubID(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *ContextPartySubID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ContextPartySubID, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEventDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::DerivativeEventDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEventDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeEventDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeEventDate'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeEventDate()\n    FIX::DerivativeEventDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideGrossTradeAmt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::SideGrossTradeAmt *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideGrossTradeAmt(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SideGrossTradeAmt__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SideGrossTradeAmt'.\n  Possible C/C++ prototypes are:\n    FIX::SideGrossTradeAmt()\n    FIX::SideGrossTradeAmt(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PeggedPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::PeggedPrice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PeggedPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PeggedPrice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PeggedPrice'.\n  Possible C/C++ prototypes are:\n    FIX::PeggedPrice()\n    FIX::PeggedPrice(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExpirationCycle__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ExpirationCycle *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExpirationCycle(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ExpirationCycle__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ExpirationCycle'.\n  Possible C/C++ prototypes are:\n    FIX::ExpirationCycle()\n    FIX::ExpirationCycle(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocCancReplaceReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::AllocCancReplaceReason *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocCancReplaceReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllocCancReplaceReason__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllocCancReplaceReason'.\n  Possible C/C++ prototypes are:\n    FIX::AllocCancReplaceReason()\n    FIX::AllocCancReplaceReason(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CxlRejReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::CxlRejReason *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CxlRejReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CxlRejReason__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CxlRejReason'.\n  Possible C/C++ prototypes are:\n    FIX::CxlRejReason()\n    FIX::CxlRejReason(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BeginString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::BeginString *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BeginString(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_BeginString__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BeginString'.\n  Possible C/C++ prototypes are:\n    FIX::BeginString()\n    FIX::BeginString(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeliverToSubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DeliverToSubID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeliverToSubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DeliverToSubID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DeliverToSubID'.\n  Possible C/C++ prototypes are:\n    FIX::DeliverToSubID()\n    FIX::DeliverToSubID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_NoRelatedPartyAltIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoRelatedPartyAltIDs *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_NoRelatedPartyAltIDs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRelatedPartyAltIDs *)new FIX::NoRelatedPartyAltIDs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRelatedPartyAltIDs, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRelatedPartyAltIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRelatedPartyAltIDs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoRelatedPartyAltIDs",&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_NoRelatedPartyAltIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoRelatedPartyAltIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRelatedPartyAltIDs *)new FIX::NoRelatedPartyAltIDs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRelatedPartyAltIDs, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRelatedPartyAltIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_NoRelatedPartyAltIDs__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoRelatedPartyAltIDs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoRelatedPartyAltIDs'.\n  Possible C/C++ prototypes are:\n    FIX::NoRelatedPartyAltIDs()\n    FIX::NoRelatedPartyAltIDs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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


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

SWIGINTERN PyObject *_wrap_new_RiskProductComplex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskProductComplex *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RiskProductComplex")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskProductComplex *)new FIX::RiskProductComplex();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskProductComplex, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RiskProductComplex(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RiskProductComplex__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskProductComplex__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskProductComplex'.\n  Possible C/C++ prototypes are:\n    FIX::RiskProductComplex()\n    FIX::RiskProductComplex(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RiskProductComplex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RiskProductComplex, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegPriceUnitOfMeasureQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::LegPriceUnitOfMeasureQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegPriceUnitOfMeasureQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegPriceUnitOfMeasureQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegPriceUnitOfMeasureQty'.\n  Possible C/C++ prototypes are:\n    FIX::LegPriceUnitOfMeasureQty()\n    FIX::LegPriceUnitOfMeasureQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoCollInquiryQualifier__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoCollInquiryQualifier *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoCollInquiryQualifier(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoCollInquiryQualifier__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoCollInquiryQualifier'.\n  Possible C/C++ prototypes are:\n    FIX::NoCollInquiryQualifier()\n    FIX::NoCollInquiryQualifier(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OfferPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::OfferPx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OfferPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OfferPx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OfferPx'.\n  Possible C/C++ prototypes are:\n    FIX::OfferPx()\n    FIX::OfferPx(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalVolumeTradedDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCDATEONLY *arg1 = 0 ;
  FIX::TotalVolumeTradedDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_TotalVolumeTradedDate",&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_TotalVolumeTradedDate" "', argument " "1"" of type '" "FIX::UTCDATEONLY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TotalVolumeTradedDate" "', argument " "1"" of type '" "FIX::UTCDATEONLY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCDATEONLY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotalVolumeTradedDate *)new FIX::TotalVolumeTradedDate((FIX::UTCDATEONLY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotalVolumeTradedDate, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalVolumeTradedDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_TotalVolumeTradedDate__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TotalVolumeTradedDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TotalVolumeTradedDate'.\n  Possible C/C++ prototypes are:\n    FIX::TotalVolumeTradedDate()\n    FIX::TotalVolumeTradedDate(FIX::UTCDATEONLY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoContAmts__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoContAmts *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoContAmts(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoContAmts__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoContAmts'.\n  Possible C/C++ prototypes are:\n    FIX::NoContAmts()\n    FIX::NoContAmts(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MinOfferSize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::MinOfferSize *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MinOfferSize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MinOfferSize__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MinOfferSize'.\n  Possible C/C++ prototypes are:\n    FIX::MinOfferSize()\n    FIX::MinOfferSize(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AvgParPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::AvgParPx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AvgParPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AvgParPx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AvgParPx'.\n  Possible C/C++ prototypes are:\n    FIX::AvgParPx()\n    FIX::AvgParPx(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegFactor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::LegFactor *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegFactor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegFactor__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegFactor'.\n  Possible C/C++ prototypes are:\n    FIX::LegFactor()\n    FIX::LegFactor(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RespondentType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::RespondentType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RespondentType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RespondentType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RespondentType'.\n  Possible C/C++ prototypes are:\n    FIX::RespondentType()\n    FIX::RespondentType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DisplayLowQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::DisplayLowQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DisplayLowQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DisplayLowQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DisplayLowQty'.\n  Possible C/C++ prototypes are:\n    FIX::DisplayLowQty()\n    FIX::DisplayLowQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DKReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::DKReason *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DKReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DKReason__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DKReason'.\n  Possible C/C++ prototypes are:\n    FIX::DKReason()\n    FIX::DKReason(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BenchmarkPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::BenchmarkPrice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BenchmarkPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_BenchmarkPrice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BenchmarkPrice'.\n  Possible C/C++ prototypes are:\n    FIX::BenchmarkPrice()\n    FIX::BenchmarkPrice(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ListID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ListID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ListID'.\n  Possible C/C++ prototypes are:\n    FIX::ListID()\n    FIX::ListID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSecurityAltID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LegSecurityAltID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSecurityAltID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegSecurityAltID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegSecurityAltID'.\n  Possible C/C++ prototypes are:\n    FIX::LegSecurityAltID()\n    FIX::LegSecurityAltID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PositionEffect__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::PositionEffect *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PositionEffect(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PositionEffect__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PositionEffect'.\n  Possible C/C++ prototypes are:\n    FIX::PositionEffect()\n    FIX::PositionEffect(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelatedPartySubIDType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelatedPartySubIDType *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelatedPartySubIDType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelatedPartySubIDType *)new FIX::RelatedPartySubIDType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelatedPartySubIDType, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RelatedPartySubIDType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelatedPartySubIDType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelatedPartySubIDType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelatedPartySubIDType'.\n  Possible C/C++ prototypes are:\n    FIX::RelatedPartySubIDType()\n    FIX::RelatedPartySubIDType(FIX::INT const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelatedPartySubIDType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelatedPartySubIDType, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerAction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::TriggerAction *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerAction(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TriggerAction__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TriggerAction'.\n  Possible C/C++ prototypes are:\n    FIX::TriggerAction()\n    FIX::TriggerAction(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefOrderID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::RefOrderID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefOrderID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RefOrderID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RefOrderID'.\n  Possible C/C++ prototypes are:\n    FIX::RefOrderID()\n    FIX::RefOrderID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClearingInstruction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ClearingInstruction *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClearingInstruction(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ClearingInstruction__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ClearingInstruction'.\n  Possible C/C++ prototypes are:\n    FIX::ClearingInstruction()\n    FIX::ClearingInstruction(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstCode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SettlInstCode *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstCode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlInstCode__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlInstCode'.\n  Possible C/C++ prototypes are:\n    FIX::SettlInstCode()\n    FIX::SettlInstCode(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NumDaysInterest__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::NumDaysInterest *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NumDaysInterest(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NumDaysInterest__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NumDaysInterest'.\n  Possible C/C++ prototypes are:\n    FIX::NumDaysInterest()\n    FIX::NumDaysInterest(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OpenCloseSettlFlag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MULTIPLECHARVALUE *arg1 = 0 ;
  FIX::OpenCloseSettlFlag *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OpenCloseSettlFlag(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OpenCloseSettlFlag__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OpenCloseSettlFlag'.\n  Possible C/C++ prototypes are:\n    FIX::OpenCloseSettlFlag()\n    FIX::OpenCloseSettlFlag(FIX::MULTIPLECHARVALUE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoComplexEventDates__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoComplexEventDates *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoComplexEventDates(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoComplexEventDates__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoComplexEventDates'.\n  Possible C/C++ prototypes are:\n    FIX::NoComplexEventDates()\n    FIX::NoComplexEventDates(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEncodedIssuerLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  FIX::DerivativeEncodedIssuerLen *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEncodedIssuerLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeEncodedIssuerLen__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeEncodedIssuerLen'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeEncodedIssuerLen()\n    FIX::DerivativeEncodedIssuerLen(FIX::LENGTH const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikeMultiplier__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::StrikeMultiplier *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikeMultiplier(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StrikeMultiplier__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StrikeMultiplier'.\n  Possible C/C++ prototypes are:\n    FIX::StrikeMultiplier()\n    FIX::StrikeMultiplier(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionMoveType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::DiscretionMoveType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionMoveType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DiscretionMoveType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DiscretionMoveType'.\n  Possible C/C++ prototypes are:\n    FIX::DiscretionMoveType()\n    FIX::DiscretionMoveType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListNoOrds__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ListNoOrds *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListNoOrds(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ListNoOrds__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ListNoOrds'.\n  Possible C/C++ prototypes are:\n    FIX::ListNoOrds()\n    FIX::ListNoOrds(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelatedPartyIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelatedPartyIDSource *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelatedPartyIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelatedPartyIDSource *)new FIX::RelatedPartyIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelatedPartyIDSource, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelatedPartyIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::RelatedPartyIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_RelatedPartyIDSource",&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_RelatedPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RelatedPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelatedPartyIDSource *)new FIX::RelatedPartyIDSource((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelatedPartyIDSource, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelatedPartyIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelatedPartyIDSource__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelatedPartyIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelatedPartyIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::RelatedPartyIDSource()\n    FIX::RelatedPartyIDSource(FIX::CHAR const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelatedPartyIDSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelatedPartyIDSource, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegSymbol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::PegSymbol *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegSymbol(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PegSymbol__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PegSymbol'.\n  Possible C/C++ prototypes are:\n    FIX::PegSymbol()\n    FIX::PegSymbol(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DayAvgPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::DayAvgPx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DayAvgPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DayAvgPx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DayAvgPx'.\n  Possible C/C++ prototypes are:\n    FIX::DayAvgPx()\n    FIX::DayAvgPx(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Headline__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::Headline *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Headline(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Headline__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Headline'.\n  Possible C/C++ prototypes are:\n    FIX::Headline()\n    FIX::Headline(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NestedPartySubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::NestedPartySubID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NestedPartySubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NestedPartySubID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NestedPartySubID'.\n  Possible C/C++ prototypes are:\n    FIX::NestedPartySubID()\n    FIX::NestedPartySubID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CardIssNo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::CardIssNo *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CardIssNo(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CardIssNo__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CardIssNo'.\n  Possible C/C++ prototypes are:\n    FIX::CardIssNo()\n    FIX::CardIssNo(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OptAttribute__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::OptAttribute *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OptAttribute(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OptAttribute__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OptAttribute'.\n  Possible C/C++ prototypes are:\n    FIX::OptAttribute()\n    FIX::OptAttribute(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastForwardPoints2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  FIX::LastForwardPoints2 *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastForwardPoints2(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LastForwardPoints2__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LastForwardPoints2'.\n  Possible C/C++ prototypes are:\n    FIX::LastForwardPoints2()\n    FIX::LastForwardPoints2(FIX::PRICEOFFSET const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDUpdateType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::MDUpdateType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDUpdateType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MDUpdateType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MDUpdateType'.\n  Possible C/C++ prototypes are:\n    FIX::MDUpdateType()\n    FIX::MDUpdateType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TickDirection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::TickDirection *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TickDirection(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TickDirection__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TickDirection'.\n  Possible C/C++ prototypes are:\n    FIX::TickDirection()\n    FIX::TickDirection(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegRedemptionDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::LegRedemptionDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegRedemptionDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegRedemptionDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegRedemptionDate'.\n  Possible C/C++ prototypes are:\n    FIX::LegRedemptionDate()\n    FIX::LegRedemptionDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikePrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::StrikePrice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikePrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StrikePrice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StrikePrice'.\n  Possible C/C++ prototypes are:\n    FIX::StrikePrice()\n    FIX::StrikePrice(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedIssuer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  FIX::EncodedIssuer *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedIssuer(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncodedIssuer__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncodedIssuer'.\n  Possible C/C++ prototypes are:\n    FIX::EncodedIssuer()\n    FIX::EncodedIssuer(FIX::DATA const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YieldType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::YieldType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YieldType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_YieldType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_YieldType'.\n  Possible C/C++ prototypes are:\n    FIX::YieldType()\n    FIX::YieldType(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradingReferencePrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::TradingReferencePrice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradingReferencePrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradingReferencePrice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradingReferencePrice'.\n  Possible C/C++ prototypes are:\n    FIX::TradingReferencePrice()\n    FIX::TradingReferencePrice(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntrySpotRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::MDEntrySpotRate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntrySpotRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MDEntrySpotRate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MDEntrySpotRate'.\n  Possible C/C++ prototypes are:\n    FIX::MDEntrySpotRate()\n    FIX::MDEntrySpotRate(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ParticipationRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::ParticipationRate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ParticipationRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ParticipationRate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ParticipationRate'.\n  Possible C/C++ prototypes are:\n    FIX::ParticipationRate()\n    FIX::ParticipationRate(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegScope__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::PegScope *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegScope(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PegScope__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PegScope'.\n  Possible C/C++ prototypes are:\n    FIX::PegScope()\n    FIX::PegScope(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InterestAtMaturity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::InterestAtMaturity *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InterestAtMaturity(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_InterestAtMaturity__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_InterestAtMaturity'.\n  Possible C/C++ prototypes are:\n    FIX::InterestAtMaturity()\n    FIX::InterestAtMaturity(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegIndividualAllocID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LegIndividualAllocID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegIndividualAllocID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegIndividualAllocID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegIndividualAllocID'.\n  Possible C/C++ prototypes are:\n    FIX::LegIndividualAllocID()\n    FIX::LegIndividualAllocID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllowableOneSidednessValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::AllowableOneSidednessValue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllowableOneSidednessValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllowableOneSidednessValue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllowableOneSidednessValue'.\n  Possible C/C++ prototypes are:\n    FIX::AllowableOneSidednessValue()\n    FIX::AllowableOneSidednessValue(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashSettlAgentName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::CashSettlAgentName *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashSettlAgentName(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CashSettlAgentName__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CashSettlAgentName'.\n  Possible C/C++ prototypes are:\n    FIX::CashSettlAgentName()\n    FIX::CashSettlAgentName(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContraTradeQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::ContraTradeQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContraTradeQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ContraTradeQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ContraTradeQty'.\n  Possible C/C++ prototypes are:\n    FIX::ContraTradeQty()\n    FIX::ContraTradeQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegMaturityTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TZTIMEONLY *arg1 = 0 ;
  FIX::LegMaturityTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegMaturityTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegMaturityTime__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegMaturityTime'.\n  Possible C/C++ prototypes are:\n    FIX::LegMaturityTime()\n    FIX::LegMaturityTime(FIX::TZTIMEONLY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlDeliveryType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::SettlDeliveryType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlDeliveryType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlDeliveryType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlDeliveryType'.\n  Possible C/C++ prototypes are:\n    FIX::SettlDeliveryType()\n    FIX::SettlDeliveryType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryPriceLimitType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::SecondaryPriceLimitType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryPriceLimitType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecondaryPriceLimitType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecondaryPriceLimitType'.\n  Possible C/C++ prototypes are:\n    FIX::SecondaryPriceLimitType()\n    FIX::SecondaryPriceLimitType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MidPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::MidPx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MidPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MidPx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MidPx'.\n  Possible C/C++ prototypes are:\n    FIX::MidPx()\n    FIX::MidPx(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AvgPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::AvgPx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AvgPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AvgPx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AvgPx'.\n  Possible C/C++ prototypes are:\n    FIX::AvgPx()\n    FIX::AvgPx(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionLimitType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::DiscretionLimitType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionLimitType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DiscretionLimitType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DiscretionLimitType'.\n  Possible C/C++ prototypes are:\n    FIX::DiscretionLimitType()\n    FIX::DiscretionLimitType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikeTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  FIX::StrikeTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikeTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  FIX::StrikeTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikeTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  FIX::StrikeTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikeTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_new_StrikeTime__SWIG_3(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StrikeTime'.\n  Possible C/C++ prototypes are:\n    FIX::StrikeTime()\n    FIX::StrikeTime(bool)\n    FIX::StrikeTime(FIX::UTCTIMESTAMP const &)\n    FIX::StrikeTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlSessSubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SettlSessSubID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlSessSubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlSessSubID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlSessSubID'.\n  Possible C/C++ prototypes are:\n    FIX::SettlSessSubID()\n    FIX::SettlSessSubID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MailingDtls__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::MailingDtls *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MailingDtls(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MailingDtls__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MailingDtls'.\n  Possible C/C++ prototypes are:\n    FIX::MailingDtls()\n    FIX::MailingDtls(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::BidID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_BidID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BidID'.\n  Possible C/C++ prototypes are:\n    FIX::BidID()\n    FIX::BidID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_PartyDetailsRequestResult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PartyDetailsRequestResult *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_PartyDetailsRequestResult")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PartyDetailsRequestResult *)new FIX::PartyDetailsRequestResult();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PartyDetailsRequestResult, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_PartyDetailsRequestResult(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_PartyDetailsRequestResult__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PartyDetailsRequestResult__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PartyDetailsRequestResult'.\n  Possible C/C++ prototypes are:\n    FIX::PartyDetailsRequestResult()\n    FIX::PartyDetailsRequestResult(FIX::INT const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *PartyDetailsRequestResult_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PartyDetailsRequestResult, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExerciseMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::ExerciseMethod *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExerciseMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ExerciseMethod__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ExerciseMethod'.\n  Possible C/C++ prototypes are:\n    FIX::ExerciseMethod()\n    FIX::ExerciseMethod(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CommCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  FIX::CommCurrency *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CommCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CommCurrency__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CommCurrency'.\n  Possible C/C++ prototypes are:\n    FIX::CommCurrency()\n    FIX::CommCurrency(FIX::CURRENCY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSettlOblig__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoSettlOblig *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSettlOblig(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoSettlOblig__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoSettlOblig'.\n  Possible C/C++ prototypes are:\n    FIX::NoSettlOblig()\n    FIX::NoSettlOblig(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaxPriceVariation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::MaxPriceVariation *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaxPriceVariation(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MaxPriceVariation__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MaxPriceVariation'.\n  Possible C/C++ prototypes are:\n    FIX::MaxPriceVariation()\n    FIX::MaxPriceVariation(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WorkingIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::WorkingIndicator *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WorkingIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_WorkingIndicator__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_WorkingIndicator'.\n  Possible C/C++ prototypes are:\n    FIX::WorkingIndicator()\n    FIX::WorkingIndicator(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashSettlAgentAcctName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::CashSettlAgentAcctName *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashSettlAgentAcctName(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CashSettlAgentAcctName__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CashSettlAgentAcctName'.\n  Possible C/C++ prototypes are:\n    FIX::CashSettlAgentAcctName()\n    FIX::CashSettlAgentAcctName(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SellVolume__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::SellVolume *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SellVolume(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SellVolume__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SellVolume'.\n  Possible C/C++ prototypes are:\n    FIX::SellVolume()\n    FIX::SellVolume(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideMultiLegReportingType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::SideMultiLegReportingType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideMultiLegReportingType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SideMultiLegReportingType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SideMultiLegReportingType'.\n  Possible C/C++ prototypes are:\n    FIX::SideMultiLegReportingType()\n    FIX::SideMultiLegReportingType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEventText__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DerivativeEventText *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEventText(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeEventText__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeEventText'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeEventText()\n    FIX::DerivativeEventText(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegSecurityDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::PegSecurityDesc *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegSecurityDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PegSecurityDesc__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PegSecurityDesc'.\n  Possible C/C++ prototypes are:\n    FIX::PegSecurityDesc()\n    FIX::PegSecurityDesc(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocCustomerCapacity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::AllocCustomerCapacity *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocCustomerCapacity(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllocCustomerCapacity__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllocCustomerCapacity'.\n  Possible C/C++ prototypes are:\n    FIX::AllocCustomerCapacity()\n    FIX::AllocCustomerCapacity(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfirmRejReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ConfirmRejReason *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfirmRejReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ConfirmRejReason__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ConfirmRejReason'.\n  Possible C/C++ prototypes are:\n    FIX::ConfirmRejReason()\n    FIX::ConfirmRejReason(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidRequestTransType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::BidRequestTransType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidRequestTransType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_BidRequestTransType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BidRequestTransType'.\n  Possible C/C++ prototypes are:\n    FIX::BidRequestTransType()\n    FIX::BidRequestTransType(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashDistribAgentAcctNumber__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::CashDistribAgentAcctNumber *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashDistribAgentAcctNumber(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CashDistribAgentAcctNumber__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CashDistribAgentAcctNumber'.\n  Possible C/C++ prototypes are:\n    FIX::CashDistribAgentAcctNumber()\n    FIX::CashDistribAgentAcctNumber(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegExecInst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MULTIPLECHARVALUE *arg1 = 0 ;
  FIX::LegExecInst *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegExecInst(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegExecInst__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegExecInst'.\n  Possible C/C++ prototypes are:\n    FIX::LegExecInst()\n    FIX::LegExecInst(FIX::MULTIPLECHARVALUE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CapPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::CapPrice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CapPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CapPrice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CapPrice'.\n  Possible C/C++ prototypes are:\n    FIX::CapPrice()\n    FIX::CapPrice(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegRepurchaseTerm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::LegRepurchaseTerm *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegRepurchaseTerm(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegRepurchaseTerm__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegRepurchaseTerm'.\n  Possible C/C++ prototypes are:\n    FIX::LegRepurchaseTerm()\n    FIX::LegRepurchaseTerm(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistAcctType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::RegistAcctType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistAcctType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RegistAcctType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RegistAcctType'.\n  Possible C/C++ prototypes are:\n    FIX::RegistAcctType()\n    FIX::RegistAcctType(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassActionRejectReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::MassActionRejectReason *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassActionRejectReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MassActionRejectReason__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MassActionRejectReason'.\n  Possible C/C++ prototypes are:\n    FIX::MassActionRejectReason()\n    FIX::MassActionRejectReason(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativePutOrCall__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::DerivativePutOrCall *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativePutOrCall(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativePutOrCall__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativePutOrCall'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativePutOrCall()\n    FIX::DerivativePutOrCall(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StartMaturityMonthYear__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MONTHYEAR *arg1 = 0 ;
  FIX::StartMaturityMonthYear *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StartMaturityMonthYear(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StartMaturityMonthYear__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StartMaturityMonthYear'.\n  Possible C/C++ prototypes are:\n    FIX::StartMaturityMonthYear()\n    FIX::StartMaturityMonthYear(FIX::MONTHYEAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollApplType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::CollApplType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollApplType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CollApplType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CollApplType'.\n  Possible C/C++ prototypes are:\n    FIX::CollApplType()\n    FIX::CollApplType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoUnderlyingAmounts__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoUnderlyingAmounts *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoUnderlyingAmounts(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoUnderlyingAmounts__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoUnderlyingAmounts'.\n  Possible C/C++ prototypes are:\n    FIX::NoUnderlyingAmounts()\n    FIX::NoUnderlyingAmounts(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfirmType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ConfirmType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfirmType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ConfirmType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ConfirmType'.\n  Possible C/C++ prototypes are:\n    FIX::ConfirmType()\n    FIX::ConfirmType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegMaturityMonthYear__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MONTHYEAR *arg1 = 0 ;
  FIX::LegMaturityMonthYear *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegMaturityMonthYear(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegMaturityMonthYear__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegMaturityMonthYear'.\n  Possible C/C++ prototypes are:\n    FIX::LegMaturityMonthYear()\n    FIX::LegMaturityMonthYear(FIX::MONTHYEAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelatdSym__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::RelatdSym *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelatdSym(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelatdSym__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelatdSym'.\n  Possible C/C++ prototypes are:\n    FIX::RelatdSym()\n    FIX::RelatdSym(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RiskLimitAmount__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskLimitAmount *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RiskLimitAmount")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskLimitAmount *)new FIX::RiskLimitAmount();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskLimitAmount, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RiskLimitAmount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::RiskLimitAmount *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_RiskLimitAmount",&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_RiskLimitAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RiskLimitAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskLimitAmount *)new FIX::RiskLimitAmount((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskLimitAmount, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RiskLimitAmount(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RiskLimitAmount__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskLimitAmount__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskLimitAmount'.\n  Possible C/C++ prototypes are:\n    FIX::RiskLimitAmount()\n    FIX::RiskLimitAmount(FIX::AMT const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RiskLimitAmount_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RiskLimitAmount, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecuritySubType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingLegSecuritySubType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecuritySubType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingLegSecuritySubType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingLegSecuritySubType'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingLegSecuritySubType()\n    FIX::UnderlyingLegSecuritySubType(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoUnderlyingSecurityAltID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoUnderlyingSecurityAltID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoUnderlyingSecurityAltID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoUnderlyingSecurityAltID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoUnderlyingSecurityAltID'.\n  Possible C/C++ prototypes are:\n    FIX::NoUnderlyingSecurityAltID()\n    FIX::NoUnderlyingSecurityAltID(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelationshipRiskCFICode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelationshipRiskCFICode *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelationshipRiskCFICode")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskCFICode *)new FIX::RelationshipRiskCFICode();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskCFICode, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RelationshipRiskCFICode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelationshipRiskCFICode__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelationshipRiskCFICode__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelationshipRiskCFICode'.\n  Possible C/C++ prototypes are:\n    FIX::RelationshipRiskCFICode()\n    FIX::RelationshipRiskCFICode(FIX::STRING const &)\n");
  return NULL;
}


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


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

SWIGINTERN PyObject *_wrap_new_NoRelatedPartySubIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoRelatedPartySubIDs *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_NoRelatedPartySubIDs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRelatedPartySubIDs *)new FIX::NoRelatedPartySubIDs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRelatedPartySubIDs, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRelatedPartySubIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRelatedPartySubIDs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoRelatedPartySubIDs",&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_NoRelatedPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoRelatedPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRelatedPartySubIDs *)new FIX::NoRelatedPartySubIDs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRelatedPartySubIDs, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRelatedPartySubIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_NoRelatedPartySubIDs__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoRelatedPartySubIDs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoRelatedPartySubIDs'.\n  Possible C/C++ prototypes are:\n    FIX::NoRelatedPartySubIDs()\n    FIX::NoRelatedPartySubIDs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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


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

SWIGINTERN PyObject *_wrap_new_RiskSymbolSfx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskSymbolSfx *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RiskSymbolSfx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskSymbolSfx *)new FIX::RiskSymbolSfx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskSymbolSfx, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RiskSymbolSfx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RiskSymbolSfx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskSymbolSfx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskSymbolSfx'.\n  Possible C/C++ prototypes are:\n    FIX::RiskSymbolSfx()\n    FIX::RiskSymbolSfx(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RiskSymbolSfx_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RiskSymbolSfx, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDQuoteType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::MDQuoteType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDQuoteType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MDQuoteType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MDQuoteType'.\n  Possible C/C++ prototypes are:\n    FIX::MDQuoteType()\n    FIX::MDQuoteType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QtyType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::QtyType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QtyType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_QtyType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_QtyType'.\n  Possible C/C++ prototypes are:\n    FIX::QtyType()\n    FIX::QtyType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteRespType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::QuoteRespType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteRespType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_QuoteRespType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_QuoteRespType'.\n  Possible C/C++ prototypes are:\n    FIX::QuoteRespType()\n    FIX::QuoteRespType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOINaturalFlag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::IOINaturalFlag *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOINaturalFlag(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_IOINaturalFlag__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_IOINaturalFlag'.\n  Possible C/C++ prototypes are:\n    FIX::IOINaturalFlag()\n    FIX::IOINaturalFlag(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BenchmarkCurvePoint__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::BenchmarkCurvePoint *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BenchmarkCurvePoint(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_BenchmarkCurvePoint__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BenchmarkCurvePoint'.\n  Possible C/C++ prototypes are:\n    FIX::BenchmarkCurvePoint()\n    FIX::BenchmarkCurvePoint(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesUpdateAction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::TradSesUpdateAction *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesUpdateAction(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradSesUpdateAction__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradSesUpdateAction'.\n  Possible C/C++ prototypes are:\n    FIX::TradSesUpdateAction()\n    FIX::TradSesUpdateAction(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCashAmount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::UnderlyingCashAmount *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCashAmount(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingCashAmount__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingCashAmount'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingCashAmount()\n    FIX::UnderlyingCashAmount(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollAsgnID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::CollAsgnID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollAsgnID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CollAsgnID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CollAsgnID'.\n  Possible C/C++ prototypes are:\n    FIX::CollAsgnID()\n    FIX::CollAsgnID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExchangeRule__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ExchangeRule *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExchangeRule(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ExchangeRule__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ExchangeRule'.\n  Possible C/C++ prototypes are:\n    FIX::ExchangeRule()\n    FIX::ExchangeRule(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedHeadline__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  FIX::EncodedHeadline *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedHeadline(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncodedHeadline__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncodedHeadline'.\n  Possible C/C++ prototypes are:\n    FIX::EncodedHeadline()\n    FIX::EncodedHeadline(FIX::DATA const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::RegistID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RegistID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RegistID'.\n  Possible C/C++ prototypes are:\n    FIX::RegistID()\n    FIX::RegistID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CrossID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::CrossID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CrossID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CrossID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CrossID'.\n  Possible C/C++ prototypes are:\n    FIX::CrossID()\n    FIX::CrossID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoExecs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoExecs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoExecs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoExecs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoExecs'.\n  Possible C/C++ prototypes are:\n    FIX::NoExecs()\n    FIX::NoExecs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityGroup__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DerivativeSecurityGroup *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityGroup(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeSecurityGroup__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeSecurityGroup'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeSecurityGroup()\n    FIX::DerivativeSecurityGroup(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryDisplayQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::SecondaryDisplayQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryDisplayQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecondaryDisplayQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecondaryDisplayQty'.\n  Possible C/C++ prototypes are:\n    FIX::SecondaryDisplayQty()\n    FIX::SecondaryDisplayQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefMsgType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::RefMsgType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefMsgType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RefMsgType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RefMsgType'.\n  Possible C/C++ prototypes are:\n    FIX::RefMsgType()\n    FIX::RefMsgType(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StandInstDbID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::StandInstDbID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StandInstDbID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StandInstDbID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StandInstDbID'.\n  Possible C/C++ prototypes are:\n    FIX::StandInstDbID()\n    FIX::StandInstDbID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedLegSecurityDescLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  FIX::EncodedLegSecurityDescLen *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedLegSecurityDescLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncodedLegSecurityDescLen__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncodedLegSecurityDescLen'.\n  Possible C/C++ prototypes are:\n    FIX::EncodedLegSecurityDescLen()\n    FIX::EncodedLegSecurityDescLen(FIX::LENGTH const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEventPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::DerivativeEventPx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEventPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeEventPx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeEventPx'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeEventPx()\n    FIX::DerivativeEventPx(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlObligSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::SettlObligSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlObligSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlObligSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlObligSource'.\n  Possible C/C++ prototypes are:\n    FIX::SettlObligSource()\n    FIX::SettlObligSource(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdSubType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TrdSubType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdSubType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TrdSubType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TrdSubType'.\n  Possible C/C++ prototypes are:\n    FIX::TrdSubType()\n    FIX::TrdSubType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedUnderlyingIssuerLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  FIX::EncodedUnderlyingIssuerLen *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedUnderlyingIssuerLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncodedUnderlyingIssuerLen__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncodedUnderlyingIssuerLen'.\n  Possible C/C++ prototypes are:\n    FIX::EncodedUnderlyingIssuerLen()\n    FIX::EncodedUnderlyingIssuerLen(FIX::LENGTH const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecTransType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::ExecTransType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecTransType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ExecTransType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ExecTransType'.\n  Possible C/C++ prototypes are:\n    FIX::ExecTransType()\n    FIX::ExecTransType(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BeginSeqNo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SEQNUM *arg1 = 0 ;
  FIX::BeginSeqNo *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BeginSeqNo(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_BeginSeqNo__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BeginSeqNo'.\n  Possible C/C++ prototypes are:\n    FIX::BeginSeqNo()\n    FIX::BeginSeqNo(FIX::SEQNUM const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DayBookingInst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::DayBookingInst *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DayBookingInst(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DayBookingInst__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DayBookingInst'.\n  Possible C/C++ prototypes are:\n    FIX::DayBookingInst()\n    FIX::DayBookingInst(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlowScheduleType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::FlowScheduleType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlowScheduleType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_FlowScheduleType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_FlowScheduleType'.\n  Possible C/C++ prototypes are:\n    FIX::FlowScheduleType()\n    FIX::FlowScheduleType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDOriginType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::MDOriginType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDOriginType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MDOriginType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MDOriginType'.\n  Possible C/C++ prototypes are:\n    FIX::MDOriginType()\n    FIX::MDOriginType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollInquiryStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::CollInquiryStatus *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollInquiryStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CollInquiryStatus__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CollInquiryStatus'.\n  Possible C/C++ prototypes are:\n    FIX::CollInquiryStatus()\n    FIX::CollInquiryStatus(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoInstrAttrib__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoInstrAttrib *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoInstrAttrib(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoInstrAttrib__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoInstrAttrib'.\n  Possible C/C++ prototypes are:\n    FIX::NoInstrAttrib()\n    FIX::NoInstrAttrib(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistEmail__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::RegistEmail *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistEmail(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RegistEmail__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RegistEmail'.\n  Possible C/C++ prototypes are:\n    FIX::RegistEmail()\n    FIX::RegistEmail(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StreamAsgnReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::StreamAsgnReqID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StreamAsgnReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StreamAsgnReqID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StreamAsgnReqID'.\n  Possible C/C++ prototypes are:\n    FIX::StreamAsgnReqID()\n    FIX::StreamAsgnReqID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPProgram__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::CPProgram *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPProgram(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CPProgram__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CPProgram'.\n  Possible C/C++ prototypes are:\n    FIX::CPProgram()\n    FIX::CPProgram(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfirmReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ConfirmReqID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfirmReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ConfirmReqID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ConfirmReqID'.\n  Possible C/C++ prototypes are:\n    FIX::ConfirmReqID()\n    FIX::ConfirmReqID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AltMDSourceID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::AltMDSourceID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AltMDSourceID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AltMDSourceID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AltMDSourceID'.\n  Possible C/C++ prototypes are:\n    FIX::AltMDSourceID()\n    FIX::AltMDSourceID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoOrders__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoOrders *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoOrders(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoOrders__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoOrders'.\n  Possible C/C++ prototypes are:\n    FIX::NoOrders()\n    FIX::NoOrders(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashDistribAgentAcctName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::CashDistribAgentAcctName *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashDistribAgentAcctName(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CashDistribAgentAcctName__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CashDistribAgentAcctName'.\n  Possible C/C++ prototypes are:\n    FIX::CashDistribAgentAcctName()\n    FIX::CashDistribAgentAcctName(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_NoContextPartySubIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoContextPartySubIDs *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_NoContextPartySubIDs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoContextPartySubIDs *)new FIX::NoContextPartySubIDs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoContextPartySubIDs, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoContextPartySubIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoContextPartySubIDs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoContextPartySubIDs",&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_NoContextPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoContextPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoContextPartySubIDs *)new FIX::NoContextPartySubIDs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoContextPartySubIDs, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoContextPartySubIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_NoContextPartySubIDs__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoContextPartySubIDs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoContextPartySubIDs'.\n  Possible C/C++ prototypes are:\n    FIX::NoContextPartySubIDs()\n    FIX::NoContextPartySubIDs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *NoContextPartySubIDs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoContextPartySubIDs, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndlyInstrumentPartyIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::UndlyInstrumentPartyIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndlyInstrumentPartyIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UndlyInstrumentPartyIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UndlyInstrumentPartyIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::UndlyInstrumentPartyIDSource()\n    FIX::UndlyInstrumentPartyIDSource(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSettlMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingSettlMethod *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSettlMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingSettlMethod__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingSettlMethod'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingSettlMethod()\n    FIX::UnderlyingSettlMethod(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoMDEntryTypes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoMDEntryTypes *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoMDEntryTypes(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoMDEntryTypes__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoMDEntryTypes'.\n  Possible C/C++ prototypes are:\n    FIX::NoMDEntryTypes()\n    FIX::NoMDEntryTypes(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryForwardPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  FIX::MDEntryForwardPoints *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryForwardPoints(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MDEntryForwardPoints__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MDEntryForwardPoints'.\n  Possible C/C++ prototypes are:\n    FIX::MDEntryForwardPoints()\n    FIX::MDEntryForwardPoints(FIX::PRICEOFFSET const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosReqType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::PosReqType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosReqType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PosReqType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PosReqType'.\n  Possible C/C++ prototypes are:\n    FIX::PosReqType()\n    FIX::PosReqType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassStatusReqType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::MassStatusReqType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassStatusReqType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MassStatusReqType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MassStatusReqType'.\n  Possible C/C++ prototypes are:\n    FIX::MassStatusReqType()\n    FIX::MassStatusReqType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeOriginationDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::TradeOriginationDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeOriginationDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradeOriginationDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradeOriginationDate'.\n  Possible C/C++ prototypes are:\n    FIX::TradeOriginationDate()\n    FIX::TradeOriginationDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::SettlPrice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlPrice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlPrice'.\n  Possible C/C++ prototypes are:\n    FIX::SettlPrice()\n    FIX::SettlPrice(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecuritySettlAgentAcctName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SecuritySettlAgentAcctName *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecuritySettlAgentAcctName(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecuritySettlAgentAcctName__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecuritySettlAgentAcctName'.\n  Possible C/C++ prototypes are:\n    FIX::SecuritySettlAgentAcctName()\n    FIX::SecuritySettlAgentAcctName(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RiskInstrumentMultiplier__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskInstrumentMultiplier *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RiskInstrumentMultiplier")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskInstrumentMultiplier *)new FIX::RiskInstrumentMultiplier();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskInstrumentMultiplier, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RiskInstrumentMultiplier__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::RiskInstrumentMultiplier *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_RiskInstrumentMultiplier",&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_RiskInstrumentMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RiskInstrumentMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskInstrumentMultiplier *)new FIX::RiskInstrumentMultiplier((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskInstrumentMultiplier, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RiskInstrumentMultiplier(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RiskInstrumentMultiplier__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskInstrumentMultiplier__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskInstrumentMultiplier'.\n  Possible C/C++ prototypes are:\n    FIX::RiskInstrumentMultiplier()\n    FIX::RiskInstrumentMultiplier(FIX::FLOAT const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RiskInstrumentMultiplier_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RiskInstrumentMultiplier, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoDerivativeEvents__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoDerivativeEvents *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoDerivativeEvents(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoDerivativeEvents__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoDerivativeEvents'.\n  Possible C/C++ prototypes are:\n    FIX::NoDerivativeEvents()\n    FIX::NoDerivativeEvents(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingEndPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::UnderlyingEndPrice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingEndPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingEndPrice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingEndPrice'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingEndPrice()\n    FIX::UnderlyingEndPrice(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SubscriptionRequestType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::SubscriptionRequestType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SubscriptionRequestType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SubscriptionRequestType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SubscriptionRequestType'.\n  Possible C/C++ prototypes are:\n    FIX::SubscriptionRequestType()\n    FIX::SubscriptionRequestType(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalNumSecurityTypes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TotalNumSecurityTypes *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalNumSecurityTypes(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TotalNumSecurityTypes__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TotalNumSecurityTypes'.\n  Possible C/C++ prototypes are:\n    FIX::TotalNumSecurityTypes()\n    FIX::TotalNumSecurityTypes(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NewsCategory__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::NewsCategory *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NewsCategory(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NewsCategory__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NewsCategory'.\n  Possible C/C++ prototypes are:\n    FIX::NewsCategory()\n    FIX::NewsCategory(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegPutOrCall__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::UnderlyingLegPutOrCall *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegPutOrCall(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingLegPutOrCall__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingLegPutOrCall'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingLegPutOrCall()\n    FIX::UnderlyingLegPutOrCall(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_URLLink__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::URLLink *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_URLLink(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_URLLink__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_URLLink'.\n  Possible C/C++ prototypes are:\n    FIX::URLLink()\n    FIX::URLLink(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoInstrumentPartySubIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoInstrumentPartySubIDs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoInstrumentPartySubIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoInstrumentPartySubIDs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoInstrumentPartySubIDs'.\n  Possible C/C++ prototypes are:\n    FIX::NoInstrumentPartySubIDs()\n    FIX::NoInstrumentPartySubIDs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCurrentValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::UnderlyingCurrentValue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCurrentValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingCurrentValue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingCurrentValue'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingCurrentValue()\n    FIX::UnderlyingCurrentValue(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InterestAccrualDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::InterestAccrualDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InterestAccrualDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_InterestAccrualDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_InterestAccrualDate'.\n  Possible C/C++ prototypes are:\n    FIX::InterestAccrualDate()\n    FIX::InterestAccrualDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FutSettDate2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::FutSettDate2 *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FutSettDate2(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_FutSettDate2__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_FutSettDate2'.\n  Possible C/C++ prototypes are:\n    FIX::FutSettDate2()\n    FIX::FutSettDate2(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoClearingInstructions__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoClearingInstructions *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoClearingInstructions(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoClearingInstructions__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoClearingInstructions'.\n  Possible C/C++ prototypes are:\n    FIX::NoClearingInstructions()\n    FIX::NoClearingInstructions(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  FIX::UnderlyingCurrency *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingCurrency__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingCurrency'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingCurrency()\n    FIX::UnderlyingCurrency(FIX::CURRENCY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegInterestAccrualDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::LegInterestAccrualDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegInterestAccrualDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegInterestAccrualDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegInterestAccrualDate'.\n  Possible C/C++ prototypes are:\n    FIX::LegInterestAccrualDate()\n    FIX::LegInterestAccrualDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NewPassword__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::NewPassword *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NewPassword(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NewPassword__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NewPassword'.\n  Possible C/C++ prototypes are:\n    FIX::NewPassword()\n    FIX::NewPassword(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RedemptionDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::RedemptionDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RedemptionDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RedemptionDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RedemptionDate'.\n  Possible C/C++ prototypes are:\n    FIX::RedemptionDate()\n    FIX::RedemptionDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefApplLastSeqNum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SEQNUM *arg1 = 0 ;
  FIX::RefApplLastSeqNum *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefApplLastSeqNum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RefApplLastSeqNum__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RefApplLastSeqNum'.\n  Possible C/C++ prototypes are:\n    FIX::RefApplLastSeqNum()\n    FIX::RefApplLastSeqNum(FIX::SEQNUM const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StartCash__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::StartCash *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StartCash(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StartCash__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StartCash'.\n  Possible C/C++ prototypes are:\n    FIX::StartCash()\n    FIX::StartCash(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaxMessageSize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  FIX::MaxMessageSize *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaxMessageSize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MaxMessageSize__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MaxMessageSize'.\n  Possible C/C++ prototypes are:\n    FIX::MaxMessageSize()\n    FIX::MaxMessageSize(FIX::LENGTH const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OfferForwardPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  FIX::OfferForwardPoints *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OfferForwardPoints(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OfferForwardPoints__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OfferForwardPoints'.\n  Possible C/C++ prototypes are:\n    FIX::OfferForwardPoints()\n    FIX::OfferForwardPoints(FIX::PRICEOFFSET const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOIQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::IOIQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOIQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_IOIQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_IOIQty'.\n  Possible C/C++ prototypes are:\n    FIX::IOIQty()\n    FIX::IOIQty(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::LastQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LastQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LastQty'.\n  Possible C/C++ prototypes are:\n    FIX::LastQty()\n    FIX::LastQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplResponseError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ApplResponseError *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplResponseError(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ApplResponseError__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ApplResponseError'.\n  Possible C/C++ prototypes are:\n    FIX::ApplResponseError()\n    FIX::ApplResponseError(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingLegSecurityType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingLegSecurityType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingLegSecurityType'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingLegSecurityType()\n    FIX::UnderlyingLegSecurityType(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativePriceUnitOfMeasure__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DerivativePriceUnitOfMeasure *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativePriceUnitOfMeasure(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativePriceUnitOfMeasure__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativePriceUnitOfMeasure'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativePriceUnitOfMeasure()\n    FIX::DerivativePriceUnitOfMeasure(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerPriceDirection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::TriggerPriceDirection *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerPriceDirection(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TriggerPriceDirection__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TriggerPriceDirection'.\n  Possible C/C++ prototypes are:\n    FIX::TriggerPriceDirection()\n    FIX::TriggerPriceDirection(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PositionCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::PositionCurrency *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PositionCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PositionCurrency__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PositionCurrency'.\n  Possible C/C++ prototypes are:\n    FIX::PositionCurrency()\n    FIX::PositionCurrency(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MessageEventSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::MessageEventSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MessageEventSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MessageEventSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MessageEventSource'.\n  Possible C/C++ prototypes are:\n    FIX::MessageEventSource()\n    FIX::MessageEventSource(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollInquiryID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::CollInquiryID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollInquiryID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CollInquiryID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CollInquiryID'.\n  Possible C/C++ prototypes are:\n    FIX::CollInquiryID()\n    FIX::CollInquiryID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingStartValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::UnderlyingStartValue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingStartValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingStartValue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingStartValue'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingStartValue()\n    FIX::UnderlyingStartValue(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastLiquidityInd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::LastLiquidityInd *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastLiquidityInd(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LastLiquidityInd__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LastLiquidityInd'.\n  Possible C/C++ prototypes are:\n    FIX::LastLiquidityInd()\n    FIX::LastLiquidityInd(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SecurityID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecurityID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecurityID'.\n  Possible C/C++ prototypes are:\n    FIX::SecurityID()\n    FIX::SecurityID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoMDEntries__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoMDEntries *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoMDEntries(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoMDEntries__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoMDEntries'.\n  Possible C/C++ prototypes are:\n    FIX::NoMDEntries()\n    FIX::NoMDEntries(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_NoPartyListResponseTypes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoPartyListResponseTypes *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_NoPartyListResponseTypes")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoPartyListResponseTypes *)new FIX::NoPartyListResponseTypes();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoPartyListResponseTypes, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoPartyListResponseTypes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoPartyListResponseTypes *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoPartyListResponseTypes",&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_NoPartyListResponseTypes" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoPartyListResponseTypes" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoPartyListResponseTypes *)new FIX::NoPartyListResponseTypes((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoPartyListResponseTypes, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoPartyListResponseTypes(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_NoPartyListResponseTypes__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoPartyListResponseTypes__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoPartyListResponseTypes'.\n  Possible C/C++ prototypes are:\n    FIX::NoPartyListResponseTypes()\n    FIX::NoPartyListResponseTypes(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *NoPartyListResponseTypes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoPartyListResponseTypes, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikePriceDeterminationMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::StrikePriceDeterminationMethod *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikePriceDeterminationMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StrikePriceDeterminationMethod__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StrikePriceDeterminationMethod'.\n  Possible C/C++ prototypes are:\n    FIX::StrikePriceDeterminationMethod()\n    FIX::StrikePriceDeterminationMethod(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EndDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::EndDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EndDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EndDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EndDate'.\n  Possible C/C++ prototypes are:\n    FIX::EndDate()\n    FIX::EndDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashOutstanding__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::CashOutstanding *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashOutstanding(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CashOutstanding__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CashOutstanding'.\n  Possible C/C++ prototypes are:\n    FIX::CashOutstanding()\n    FIX::CashOutstanding(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::MDReqID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MDReqID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MDReqID'.\n  Possible C/C++ prototypes are:\n    FIX::MDReqID()\n    FIX::MDReqID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOIRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::IOIRefID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOIRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_IOIRefID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_IOIRefID'.\n  Possible C/C++ prototypes are:\n    FIX::IOIRefID()\n    FIX::IOIRefID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_NoContextPartyIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoContextPartyIDs *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_NoContextPartyIDs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoContextPartyIDs *)new FIX::NoContextPartyIDs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoContextPartyIDs, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoContextPartyIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoContextPartyIDs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoContextPartyIDs",&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_NoContextPartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoContextPartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoContextPartyIDs *)new FIX::NoContextPartyIDs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoContextPartyIDs, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoContextPartyIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_NoContextPartyIDs__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoContextPartyIDs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoContextPartyIDs'.\n  Possible C/C++ prototypes are:\n    FIX::NoContextPartyIDs()\n    FIX::NoContextPartyIDs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *NoContextPartyIDs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoContextPartyIDs, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetStrategy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TargetStrategy *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetStrategy(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TargetStrategy__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TargetStrategy'.\n  Possible C/C++ prototypes are:\n    FIX::TargetStrategy()\n    FIX::TargetStrategy(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfirmRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ConfirmRefID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfirmRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ConfirmRefID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ConfirmRefID'.\n  Possible C/C++ prototypes are:\n    FIX::ConfirmRefID()\n    FIX::ConfirmRefID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SellerDays__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::SellerDays *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SellerDays(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SellerDays__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SellerDays'.\n  Possible C/C++ prototypes are:\n    FIX::SellerDays()\n    FIX::SellerDays(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DueToRelated__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::DueToRelated *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DueToRelated(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DueToRelated__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DueToRelated'.\n  Possible C/C++ prototypes are:\n    FIX::DueToRelated()\n    FIX::DueToRelated(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryTradingReferencePrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::SecondaryTradingReferencePrice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryTradingReferencePrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecondaryTradingReferencePrice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecondaryTradingReferencePrice'.\n  Possible C/C++ prototypes are:\n    FIX::SecondaryTradingReferencePrice()\n    FIX::SecondaryTradingReferencePrice(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoMDFeedTypes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoMDFeedTypes *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoMDFeedTypes(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoMDFeedTypes__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoMDFeedTypes'.\n  Possible C/C++ prototypes are:\n    FIX::NoMDFeedTypes()\n    FIX::NoMDFeedTypes(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingInstrumentPartySubIDType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::UnderlyingInstrumentPartySubIDType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingInstrumentPartySubIDType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingInstrumentPartySubIDType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingInstrumentPartySubIDType'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingInstrumentPartySubIDType()\n    FIX::UnderlyingInstrumentPartySubIDType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesCloseTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  FIX::TradSesCloseTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesCloseTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  FIX::TradSesCloseTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesCloseTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  FIX::TradSesCloseTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesCloseTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_new_TradSesCloseTime__SWIG_3(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradSesCloseTime'.\n  Possible C/C++ prototypes are:\n    FIX::TradSesCloseTime()\n    FIX::TradSesCloseTime(bool)\n    FIX::TradSesCloseTime(FIX::UTCTIMESTAMP const &)\n    FIX::TradSesCloseTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContractSettlMonth__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MONTHYEAR *arg1 = 0 ;
  FIX::ContractSettlMonth *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContractSettlMonth(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ContractSettlMonth__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ContractSettlMonth'.\n  Possible C/C++ prototypes are:\n    FIX::ContractSettlMonth()\n    FIX::ContractSettlMonth(FIX::MONTHYEAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeStrikePrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::DerivativeStrikePrice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeStrikePrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeStrikePrice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeStrikePrice'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeStrikePrice()\n    FIX::DerivativeStrikePrice(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerSecurityDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::TriggerSecurityDesc *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerSecurityDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TriggerSecurityDesc__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TriggerSecurityDesc'.\n  Possible C/C++ prototypes are:\n    FIX::TriggerSecurityDesc()\n    FIX::TriggerSecurityDesc(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCashType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingCashType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCashType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingCashType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingCashType'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingCashType()\n    FIX::UnderlyingCashType(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoMiscFees__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoMiscFees *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoMiscFees(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoMiscFees__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoMiscFees'.\n  Possible C/C++ prototypes are:\n    FIX::NoMiscFees()\n    FIX::NoMiscFees(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CustOrderCapacity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::CustOrderCapacity *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CustOrderCapacity(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CustOrderCapacity__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CustOrderCapacity'.\n  Possible C/C++ prototypes are:\n    FIX::CustOrderCapacity()\n    FIX::CustOrderCapacity(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RiskSecurityExchange__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskSecurityExchange *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RiskSecurityExchange")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskSecurityExchange *)new FIX::RiskSecurityExchange();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskSecurityExchange, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RiskSecurityExchange__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EXCHANGE *arg1 = 0 ;
  FIX::RiskSecurityExchange *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_RiskSecurityExchange",&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_RiskSecurityExchange" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RiskSecurityExchange" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::EXCHANGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskSecurityExchange *)new FIX::RiskSecurityExchange((FIX::EXCHANGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskSecurityExchange, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RiskSecurityExchange(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RiskSecurityExchange__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskSecurityExchange__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskSecurityExchange'.\n  Possible C/C++ prototypes are:\n    FIX::RiskSecurityExchange()\n    FIX::RiskSecurityExchange(FIX::EXCHANGE const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RiskSecurityExchange_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RiskSecurityExchange, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegAllocSettlCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  FIX::LegAllocSettlCurrency *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegAllocSettlCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegAllocSettlCurrency__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegAllocSettlCurrency'.\n  Possible C/C++ prototypes are:\n    FIX::LegAllocSettlCurrency()\n    FIX::LegAllocSettlCurrency(FIX::CURRENCY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingAdjustedQuantity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::UnderlyingAdjustedQuantity *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingAdjustedQuantity(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingAdjustedQuantity__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingAdjustedQuantity'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingAdjustedQuantity()\n    FIX::UnderlyingAdjustedQuantity(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OwnershipType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::OwnershipType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OwnershipType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OwnershipType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OwnershipType'.\n  Possible C/C++ prototypes are:\n    FIX::OwnershipType()\n    FIX::OwnershipType(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaxShow__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::MaxShow *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaxShow(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MaxShow__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MaxShow'.\n  Possible C/C++ prototypes are:\n    FIX::MaxShow()\n    FIX::MaxShow(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSecurityID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LegSecurityID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSecurityID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegSecurityID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegSecurityID'.\n  Possible C/C++ prototypes are:\n    FIX::LegSecurityID()\n    FIX::LegSecurityID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_EncodedSymbol__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedSymbol *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_EncodedSymbol")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedSymbol *)new FIX::EncodedSymbol();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedSymbol, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedSymbol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  FIX::EncodedSymbol *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncodedSymbol",&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_EncodedSymbol" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncodedSymbol" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedSymbol *)new FIX::EncodedSymbol((FIX::DATA const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedSymbol, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedSymbol(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_EncodedSymbol__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncodedSymbol__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncodedSymbol'.\n  Possible C/C++ prototypes are:\n    FIX::EncodedSymbol()\n    FIX::EncodedSymbol(FIX::DATA const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *EncodedSymbol_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__EncodedSymbol, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DerivativeSecurityDesc *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeSecurityDesc__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeSecurityDesc'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeSecurityDesc()\n    FIX::DerivativeSecurityDesc(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnitOfMeasure__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnitOfMeasure *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnitOfMeasure(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnitOfMeasure__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnitOfMeasure'.\n  Possible C/C++ prototypes are:\n    FIX::UnitOfMeasure()\n    FIX::UnitOfMeasure(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_SecDefStatus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecDefStatus *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_SecDefStatus")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecDefStatus *)new FIX::SecDefStatus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecDefStatus, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_SecDefStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_SecDefStatus__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecDefStatus__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecDefStatus'.\n  Possible C/C++ prototypes are:\n    FIX::SecDefStatus()\n    FIX::SecDefStatus(FIX::INT const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *SecDefStatus_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SecDefStatus, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Quantity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::Quantity *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Quantity(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Quantity__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Quantity'.\n  Possible C/C++ prototypes are:\n    FIX::Quantity()\n    FIX::Quantity(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NewsID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::NewsID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NewsID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NewsID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NewsID'.\n  Possible C/C++ prototypes are:\n    FIX::NewsID()\n    FIX::NewsID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndlyInstrumentPartySubIDType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::UndlyInstrumentPartySubIDType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndlyInstrumentPartySubIDType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UndlyInstrumentPartySubIDType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UndlyInstrumentPartySubIDType'.\n  Possible C/C++ prototypes are:\n    FIX::UndlyInstrumentPartySubIDType()\n    FIX::UndlyInstrumentPartySubIDType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettleOnOpenFlag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SettleOnOpenFlag *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettleOnOpenFlag(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettleOnOpenFlag__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettleOnOpenFlag'.\n  Possible C/C++ prototypes are:\n    FIX::SettleOnOpenFlag()\n    FIX::SettleOnOpenFlag(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastUpdateTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  FIX::LastUpdateTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastUpdateTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  FIX::LastUpdateTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastUpdateTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  FIX::LastUpdateTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastUpdateTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_new_LastUpdateTime__SWIG_3(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LastUpdateTime'.\n  Possible C/C++ prototypes are:\n    FIX::LastUpdateTime()\n    FIX::LastUpdateTime(bool)\n    FIX::LastUpdateTime(FIX::UTCTIMESTAMP const &)\n    FIX::LastUpdateTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RepurchaseRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::RepurchaseRate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RepurchaseRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RepurchaseRate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RepurchaseRate'.\n  Possible C/C++ prototypes are:\n    FIX::RepurchaseRate()\n    FIX::RepurchaseRate(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RepurchaseTerm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::RepurchaseTerm *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RepurchaseTerm(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RepurchaseTerm__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RepurchaseTerm'.\n  Possible C/C++ prototypes are:\n    FIX::RepurchaseTerm()\n    FIX::RepurchaseTerm(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NestedPartyRole__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::NestedPartyRole *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NestedPartyRole(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NestedPartyRole__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NestedPartyRole'.\n  Possible C/C++ prototypes are:\n    FIX::NestedPartyRole()\n    FIX::NestedPartyRole(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryExecID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SecondaryExecID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryExecID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecondaryExecID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecondaryExecID'.\n  Possible C/C++ prototypes are:\n    FIX::SecondaryExecID()\n    FIX::SecondaryExecID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Pool__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::Pool *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Pool(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Pool__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Pool'.\n  Possible C/C++ prototypes are:\n    FIX::Pool()\n    FIX::Pool(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTickRules__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoTickRules *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTickRules(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoTickRules__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoTickRules'.\n  Possible C/C++ prototypes are:\n    FIX::NoTickRules()\n    FIX::NoTickRules(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Volatility__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::Volatility *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Volatility(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Volatility__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Volatility'.\n  Possible C/C++ prototypes are:\n    FIX::Volatility()\n    FIX::Volatility(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PctAtRisk__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::PctAtRisk *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PctAtRisk(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PctAtRisk__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PctAtRisk'.\n  Possible C/C++ prototypes are:\n    FIX::PctAtRisk()\n    FIX::PctAtRisk(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityExchange__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EXCHANGE *arg1 = 0 ;
  FIX::UnderlyingSecurityExchange *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityExchange(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingSecurityExchange__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingSecurityExchange'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingSecurityExchange()\n    FIX::UnderlyingSecurityExchange(FIX::EXCHANGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegStrikePrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::LegStrikePrice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegStrikePrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegStrikePrice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegStrikePrice'.\n  Possible C/C++ prototypes are:\n    FIX::LegStrikePrice()\n    FIX::LegStrikePrice(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlmntTyp__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::SettlmntTyp *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlmntTyp(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlmntTyp__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlmntTyp'.\n  Possible C/C++ prototypes are:\n    FIX::SettlmntTyp()\n    FIX::SettlmntTyp(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradePublishIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TradePublishIndicator *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradePublishIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradePublishIndicator__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradePublishIndicator'.\n  Possible C/C++ prototypes are:\n    FIX::TradePublishIndicator()\n    FIX::TradePublishIndicator(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplResponseType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ApplResponseType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplResponseType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ApplResponseType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ApplResponseType'.\n  Possible C/C++ prototypes are:\n    FIX::ApplResponseType()\n    FIX::ApplResponseType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDSubBookType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::MDSubBookType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDSubBookType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MDSubBookType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MDSubBookType'.\n  Possible C/C++ prototypes are:\n    FIX::MDSubBookType()\n    FIX::MDSubBookType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Username__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::Username *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Username(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Username__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Username'.\n  Possible C/C++ prototypes are:\n    FIX::Username()\n    FIX::Username(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StandInstDbType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::StandInstDbType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StandInstDbType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StandInstDbType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StandInstDbType'.\n  Possible C/C++ prototypes are:\n    FIX::StandInstDbType()\n    FIX::StandInstDbType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelatedContextPartyIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelatedContextPartyIDSource *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelatedContextPartyIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelatedContextPartyIDSource *)new FIX::RelatedContextPartyIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelatedContextPartyIDSource, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelatedContextPartyIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::RelatedContextPartyIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_RelatedContextPartyIDSource",&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_RelatedContextPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RelatedContextPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelatedContextPartyIDSource *)new FIX::RelatedContextPartyIDSource((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelatedContextPartyIDSource, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelatedContextPartyIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelatedContextPartyIDSource__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelatedContextPartyIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelatedContextPartyIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::RelatedContextPartyIDSource()\n    FIX::RelatedContextPartyIDSource(FIX::CHAR const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelatedContextPartyIDSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelatedContextPartyIDSource, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteEntryStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::QuoteEntryStatus *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteEntryStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_QuoteEntryStatus__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_QuoteEntryStatus'.\n  Possible C/C++ prototypes are:\n    FIX::QuoteEntryStatus()\n    FIX::QuoteEntryStatus(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerPriceType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::TriggerPriceType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerPriceType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TriggerPriceType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TriggerPriceType'.\n  Possible C/C++ prototypes are:\n    FIX::TriggerPriceType()\n    FIX::TriggerPriceType(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideTrdSubTyp__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::SideTrdSubTyp *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideTrdSubTyp(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SideTrdSubTyp__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SideTrdSubTyp'.\n  Possible C/C++ prototypes are:\n    FIX::SideTrdSubTyp()\n    FIX::SideTrdSubTyp(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingTradingSessionSubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingTradingSessionSubID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingTradingSessionSubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingTradingSessionSubID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingTradingSessionSubID'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingTradingSessionSubID()\n    FIX::UnderlyingTradingSessionSubID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstReqRejCode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::SettlInstReqRejCode *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstReqRejCode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlInstReqRejCode__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlInstReqRejCode'.\n  Possible C/C++ prototypes are:\n    FIX::SettlInstReqRejCode()\n    FIX::SettlInstReqRejCode(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MktBidPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::MktBidPx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MktBidPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MktBidPx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MktBidPx'.\n  Possible C/C++ prototypes are:\n    FIX::MktBidPx()\n    FIX::MktBidPx(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSymbol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingLegSymbol *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSymbol(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingLegSymbol__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingLegSymbol'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingLegSymbol()\n    FIX::UnderlyingLegSymbol(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikeValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::StrikeValue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikeValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StrikeValue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StrikeValue'.\n  Possible C/C++ prototypes are:\n    FIX::StrikeValue()\n    FIX::StrikeValue(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Urgency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::Urgency *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Urgency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Urgency__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Urgency'.\n  Possible C/C++ prototypes are:\n    FIX::Urgency()\n    FIX::Urgency(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::AllocID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllocID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllocID'.\n  Possible C/C++ prototypes are:\n    FIX::AllocID()\n    FIX::AllocID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_NoPartyList__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoPartyList *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_NoPartyList")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoPartyList *)new FIX::NoPartyList();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoPartyList, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoPartyList__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoPartyList *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoPartyList",&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_NoPartyList" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoPartyList" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoPartyList *)new FIX::NoPartyList((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoPartyList, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoPartyList(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_NoPartyList__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoPartyList__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoPartyList'.\n  Possible C/C++ prototypes are:\n    FIX::NoPartyList()\n    FIX::NoPartyList(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *NoPartyList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoPartyList, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingDeliveryAmount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::UnderlyingDeliveryAmount *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingDeliveryAmount(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingDeliveryAmount__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingDeliveryAmount'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingDeliveryAmount()\n    FIX::UnderlyingDeliveryAmount(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::SideQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SideQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SideQty'.\n  Possible C/C++ prototypes are:\n    FIX::SideQty()\n    FIX::SideQty(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollAsgnTransType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::CollAsgnTransType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollAsgnTransType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CollAsgnTransType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CollAsgnTransType'.\n  Possible C/C++ prototypes are:\n    FIX::CollAsgnTransType()\n    FIX::CollAsgnTransType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ThresholdAmount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  FIX::ThresholdAmount *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ThresholdAmount(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ThresholdAmount__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ThresholdAmount'.\n  Possible C/C++ prototypes are:\n    FIX::ThresholdAmount()\n    FIX::ThresholdAmount(FIX::PRICEOFFSET const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefBidSize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::DefBidSize *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefBidSize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DefBidSize__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DefBidSize'.\n  Possible C/C++ prototypes are:\n    FIX::DefBidSize()\n    FIX::DefBidSize(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegStateOrProvinceOfIssue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LegStateOrProvinceOfIssue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegStateOrProvinceOfIssue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegStateOrProvinceOfIssue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegStateOrProvinceOfIssue'.\n  Possible C/C++ prototypes are:\n    FIX::LegStateOrProvinceOfIssue()\n    FIX::LegStateOrProvinceOfIssue(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PaymentMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::PaymentMethod *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PaymentMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PaymentMethod__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PaymentMethod'.\n  Possible C/C++ prototypes are:\n    FIX::PaymentMethod()\n    FIX::PaymentMethod(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RiskCouponRate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskCouponRate *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RiskCouponRate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskCouponRate *)new FIX::RiskCouponRate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskCouponRate, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RiskCouponRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::RiskCouponRate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_RiskCouponRate",&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_RiskCouponRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RiskCouponRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskCouponRate *)new FIX::RiskCouponRate((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskCouponRate, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RiskCouponRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RiskCouponRate__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskCouponRate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskCouponRate'.\n  Possible C/C++ prototypes are:\n    FIX::RiskCouponRate()\n    FIX::RiskCouponRate(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RiskCouponRate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RiskCouponRate, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegOptAttribute__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::UnderlyingLegOptAttribute *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegOptAttribute(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingLegOptAttribute__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingLegOptAttribute'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingLegOptAttribute()\n    FIX::UnderlyingLegOptAttribute(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegVolatility__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::LegVolatility *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegVolatility(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegVolatility__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegVolatility'.\n  Possible C/C++ prototypes are:\n    FIX::LegVolatility()\n    FIX::LegVolatility(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrAttribType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::DerivativeInstrAttribType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrAttribType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeInstrAttribType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeInstrAttribType'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeInstrAttribType()\n    FIX::DerivativeInstrAttribType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeUnitOfMeasureQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::DerivativeUnitOfMeasureQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeUnitOfMeasureQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeUnitOfMeasureQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeUnitOfMeasureQty'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeUnitOfMeasureQty()\n    FIX::DerivativeUnitOfMeasureQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoStatsIndicators__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoStatsIndicators *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoStatsIndicators(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoStatsIndicators__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoStatsIndicators'.\n  Possible C/C++ prototypes are:\n    FIX::NoStatsIndicators()\n    FIX::NoStatsIndicators(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerPriceTypeScope__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::TriggerPriceTypeScope *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerPriceTypeScope(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TriggerPriceTypeScope__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TriggerPriceTypeScope'.\n  Possible C/C++ prototypes are:\n    FIX::TriggerPriceTypeScope()\n    FIX::TriggerPriceTypeScope(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastNetworkResponseID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LastNetworkResponseID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastNetworkResponseID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LastNetworkResponseID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LastNetworkResponseID'.\n  Possible C/C++ prototypes are:\n    FIX::LastNetworkResponseID()\n    FIX::LastNetworkResponseID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSettlPriceType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::UnderlyingSettlPriceType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSettlPriceType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingSettlPriceType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingSettlPriceType'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingSettlPriceType()\n    FIX::UnderlyingSettlPriceType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplReportID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ApplReportID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplReportID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ApplReportID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ApplReportID'.\n  Possible C/C++ prototypes are:\n    FIX::ApplReportID()\n    FIX::ApplReportID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegLimitType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::PegLimitType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegLimitType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PegLimitType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PegLimitType'.\n  Possible C/C++ prototypes are:\n    FIX::PegLimitType()\n    FIX::PegLimitType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ExecID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ExecID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ExecID'.\n  Possible C/C++ prototypes are:\n    FIX::ExecID()\n    FIX::ExecID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Side__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::Side *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Side(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Side__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Side'.\n  Possible C/C++ prototypes are:\n    FIX::Side()\n    FIX::Side(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLastPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::UnderlyingLastPx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLastPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingLastPx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingLastPx'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingLastPx()\n    FIX::UnderlyingLastPx(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarketDepth__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::MarketDepth *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarketDepth(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MarketDepth__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MarketDepth'.\n  Possible C/C++ prototypes are:\n    FIX::MarketDepth()\n    FIX::MarketDepth(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionOffset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  FIX::DiscretionOffset *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionOffset(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DiscretionOffset__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DiscretionOffset'.\n  Possible C/C++ prototypes are:\n    FIX::DiscretionOffset()\n    FIX::DiscretionOffset(FIX::PRICEOFFSET const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContAmtType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ContAmtType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContAmtType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ContAmtType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ContAmtType'.\n  Possible C/C++ prototypes are:\n    FIX::ContAmtType()\n    FIX::ContAmtType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MiscFeeCurr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  FIX::MiscFeeCurr *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MiscFeeCurr(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MiscFeeCurr__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MiscFeeCurr'.\n  Possible C/C++ prototypes are:\n    FIX::MiscFeeCurr()\n    FIX::MiscFeeCurr(FIX::CURRENCY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_NoRiskLimits__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoRiskLimits *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_NoRiskLimits")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRiskLimits *)new FIX::NoRiskLimits();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRiskLimits, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRiskLimits__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRiskLimits *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoRiskLimits",&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_NoRiskLimits" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoRiskLimits" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRiskLimits *)new FIX::NoRiskLimits((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRiskLimits, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRiskLimits(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_NoRiskLimits__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoRiskLimits__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoRiskLimits'.\n  Possible C/C++ prototypes are:\n    FIX::NoRiskLimits()\n    FIX::NoRiskLimits(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *NoRiskLimits_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoRiskLimits, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AttachmentPoint__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::AttachmentPoint *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AttachmentPoint(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AttachmentPoint__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AttachmentPoint'.\n  Possible C/C++ prototypes are:\n    FIX::AttachmentPoint()\n    FIX::AttachmentPoint(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderCategory__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::OrderCategory *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderCategory(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OrderCategory__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OrderCategory'.\n  Possible C/C++ prototypes are:\n    FIX::OrderCategory()\n    FIX::OrderCategory(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AdvTransType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::AdvTransType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AdvTransType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AdvTransType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AdvTransType'.\n  Possible C/C++ prototypes are:\n    FIX::AdvTransType()\n    FIX::AdvTransType(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WtAverageLiquidity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::WtAverageLiquidity *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WtAverageLiquidity(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_WtAverageLiquidity__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_WtAverageLiquidity'.\n  Possible C/C++ prototypes are:\n    FIX::WtAverageLiquidity()\n    FIX::WtAverageLiquidity(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteSetValidUntilTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  FIX::QuoteSetValidUntilTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteSetValidUntilTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  FIX::QuoteSetValidUntilTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteSetValidUntilTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  FIX::QuoteSetValidUntilTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteSetValidUntilTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_new_QuoteSetValidUntilTime__SWIG_3(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_QuoteSetValidUntilTime'.\n  Possible C/C++ prototypes are:\n    FIX::QuoteSetValidUntilTime()\n    FIX::QuoteSetValidUntilTime(bool)\n    FIX::QuoteSetValidUntilTime(FIX::UTCTIMESTAMP const &)\n    FIX::QuoteSetValidUntilTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNested4PartyIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoNested4PartyIDs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNested4PartyIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoNested4PartyIDs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoNested4PartyIDs'.\n  Possible C/C++ prototypes are:\n    FIX::NoNested4PartyIDs()\n    FIX::NoNested4PartyIDs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegPutOrCall__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::LegPutOrCall *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegPutOrCall(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegPutOrCall__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegPutOrCall'.\n  Possible C/C++ prototypes are:\n    FIX::LegPutOrCall()\n    FIX::LegPutOrCall(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UserStatusText__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UserStatusText *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UserStatusText(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UserStatusText__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UserStatusText'.\n  Possible C/C++ prototypes are:\n    FIX::UserStatusText()\n    FIX::UserStatusText(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested2PartySubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::Nested2PartySubID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested2PartySubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Nested2PartySubID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Nested2PartySubID'.\n  Possible C/C++ prototypes are:\n    FIX::Nested2PartySubID()\n    FIX::Nested2PartySubID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EFPTrackingError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::EFPTrackingError *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EFPTrackingError(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EFPTrackingError__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EFPTrackingError'.\n  Possible C/C++ prototypes are:\n    FIX::EFPTrackingError()\n    FIX::EFPTrackingError(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideLiquidityInd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::SideLiquidityInd *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideLiquidityInd(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SideLiquidityInd__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SideLiquidityInd'.\n  Possible C/C++ prototypes are:\n    FIX::SideLiquidityInd()\n    FIX::SideLiquidityInd(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeMinPriceIncrement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::DerivativeMinPriceIncrement *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeMinPriceIncrement(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeMinPriceIncrement__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeMinPriceIncrement'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeMinPriceIncrement()\n    FIX::DerivativeMinPriceIncrement(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PublishTrdIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::PublishTrdIndicator *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PublishTrdIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PublishTrdIndicator__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PublishTrdIndicator'.\n  Possible C/C++ prototypes are:\n    FIX::PublishTrdIndicator()\n    FIX::PublishTrdIndicator(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvestorCountryOfResidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::COUNTRY *arg1 = 0 ;
  FIX::InvestorCountryOfResidence *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvestorCountryOfResidence(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_InvestorCountryOfResidence__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_InvestorCountryOfResidence'.\n  Possible C/C++ prototypes are:\n    FIX::InvestorCountryOfResidence()\n    FIX::InvestorCountryOfResidence(FIX::COUNTRY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideReasonCd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SideReasonCd *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideReasonCd(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SideReasonCd__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SideReasonCd'.\n  Possible C/C++ prototypes are:\n    FIX::SideReasonCd()\n    FIX::SideReasonCd(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MinPriceIncrement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::MinPriceIncrement *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MinPriceIncrement(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MinPriceIncrement__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MinPriceIncrement'.\n  Possible C/C++ prototypes are:\n    FIX::MinPriceIncrement()\n    FIX::MinPriceIncrement(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecuritySettlAgentContactName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SecuritySettlAgentContactName *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecuritySettlAgentContactName(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecuritySettlAgentContactName__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecuritySettlAgentContactName'.\n  Possible C/C++ prototypes are:\n    FIX::SecuritySettlAgentContactName()\n    FIX::SecuritySettlAgentContactName(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityResponseType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::SecurityResponseType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityResponseType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecurityResponseType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecurityResponseType'.\n  Possible C/C++ prototypes are:\n    FIX::SecurityResponseType()\n    FIX::SecurityResponseType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegBenchmarkCurvePoint__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LegBenchmarkCurvePoint *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegBenchmarkCurvePoint(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegBenchmarkCurvePoint__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegBenchmarkCurvePoint'.\n  Possible C/C++ prototypes are:\n    FIX::LegBenchmarkCurvePoint()\n    FIX::LegBenchmarkCurvePoint(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClearingFirm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ClearingFirm *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClearingFirm(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ClearingFirm__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ClearingFirm'.\n  Possible C/C++ prototypes are:\n    FIX::ClearingFirm()\n    FIX::ClearingFirm(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelationshipRiskSecurityIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelationshipRiskSecurityIDSource *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelationshipRiskSecurityIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskSecurityIDSource *)new FIX::RelationshipRiskSecurityIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskSecurityIDSource, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RelationshipRiskSecurityIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelationshipRiskSecurityIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelationshipRiskSecurityIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelationshipRiskSecurityIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::RelationshipRiskSecurityIDSource()\n    FIX::RelationshipRiskSecurityIDSource(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelationshipRiskSecurityIDSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelationshipRiskSecurityIDSource, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::SessionStatus *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SessionStatus__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SessionStatus'.\n  Possible C/C++ prototypes are:\n    FIX::SessionStatus()\n    FIX::SessionStatus(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerSecurityID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::TriggerSecurityID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerSecurityID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TriggerSecurityID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TriggerSecurityID'.\n  Possible C/C++ prototypes are:\n    FIX::TriggerSecurityID()\n    FIX::TriggerSecurityID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoAllocs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TotNoAllocs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoAllocs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TotNoAllocs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TotNoAllocs'.\n  Possible C/C++ prototypes are:\n    FIX::TotNoAllocs()\n    FIX::TotNoAllocs(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoAltMDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoAltMDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoAltMDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoAltMDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoAltMDSource'.\n  Possible C/C++ prototypes are:\n    FIX::NoAltMDSource()\n    FIX::NoAltMDSource(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocAccountType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::AllocAccountType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocAccountType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllocAccountType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllocAccountType'.\n  Possible C/C++ prototypes are:\n    FIX::AllocAccountType()\n    FIX::AllocAccountType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::LastPx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LastPx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LastPx'.\n  Possible C/C++ prototypes are:\n    FIX::LastPx()\n    FIX::LastPx(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocTransType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::AllocTransType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocTransType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllocTransType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllocTransType'.\n  Possible C/C++ prototypes are:\n    FIX::AllocTransType()\n    FIX::AllocTransType(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoQuoteEntries__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TotNoQuoteEntries *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoQuoteEntries(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TotNoQuoteEntries__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TotNoQuoteEntries'.\n  Possible C/C++ prototypes are:\n    FIX::TotNoQuoteEntries()\n    FIX::TotNoQuoteEntries(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MinBidSize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::MinBidSize *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MinBidSize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MinBidSize__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MinBidSize'.\n  Possible C/C++ prototypes are:\n    FIX::MinBidSize()\n    FIX::MinBidSize(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlBrkrCode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SettlBrkrCode *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlBrkrCode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlBrkrCode__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlBrkrCode'.\n  Possible C/C++ prototypes are:\n    FIX::SettlBrkrCode()\n    FIX::SettlBrkrCode(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CardHolderName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::CardHolderName *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CardHolderName(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CardHolderName__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CardHolderName'.\n  Possible C/C++ prototypes are:\n    FIX::CardHolderName()\n    FIX::CardHolderName(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExpirationQtyType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ExpirationQtyType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExpirationQtyType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ExpirationQtyType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ExpirationQtyType'.\n  Possible C/C++ prototypes are:\n    FIX::ExpirationQtyType()\n    FIX::ExpirationQtyType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedUnderlyingSecurityDescLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  FIX::EncodedUnderlyingSecurityDescLen *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedUnderlyingSecurityDescLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncodedUnderlyingSecurityDescLen__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncodedUnderlyingSecurityDescLen'.\n  Possible C/C++ prototypes are:\n    FIX::EncodedUnderlyingSecurityDescLen()\n    FIX::EncodedUnderlyingSecurityDescLen(FIX::LENGTH const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::QuoteReqID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_QuoteReqID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_QuoteReqID'.\n  Possible C/C++ prototypes are:\n    FIX::QuoteReqID()\n    FIX::QuoteReqID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_NoRelatedPartyAltSubIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoRelatedPartyAltSubIDs *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_NoRelatedPartyAltSubIDs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRelatedPartyAltSubIDs *)new FIX::NoRelatedPartyAltSubIDs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRelatedPartyAltSubIDs, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRelatedPartyAltSubIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRelatedPartyAltSubIDs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoRelatedPartyAltSubIDs",&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_NoRelatedPartyAltSubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoRelatedPartyAltSubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRelatedPartyAltSubIDs *)new FIX::NoRelatedPartyAltSubIDs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRelatedPartyAltSubIDs, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRelatedPartyAltSubIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_NoRelatedPartyAltSubIDs__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoRelatedPartyAltSubIDs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoRelatedPartyAltSubIDs'.\n  Possible C/C++ prototypes are:\n    FIX::NoRelatedPartyAltSubIDs()\n    FIX::NoRelatedPartyAltSubIDs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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


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

SWIGINTERN PyObject *_wrap_new_RiskProduct__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskProduct *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RiskProduct")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskProduct *)new FIX::RiskProduct();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskProduct, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RiskProduct(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RiskProduct__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskProduct__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskProduct'.\n  Possible C/C++ prototypes are:\n    FIX::RiskProduct()\n    FIX::RiskProduct(FIX::INT const &)\n");
  return NULL;
}


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


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

SWIGINTERN PyObject *_wrap_new_RiskSecurityAltIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskSecurityAltIDSource *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RiskSecurityAltIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskSecurityAltIDSource *)new FIX::RiskSecurityAltIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskSecurityAltIDSource, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RiskSecurityAltIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RiskSecurityAltIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskSecurityAltIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskSecurityAltIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::RiskSecurityAltIDSource()\n    FIX::RiskSecurityAltIDSource(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RiskSecurityAltIDSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RiskSecurityAltIDSource, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriceUnitOfMeasure__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::PriceUnitOfMeasure *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriceUnitOfMeasure(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PriceUnitOfMeasure__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PriceUnitOfMeasure'.\n  Possible C/C++ prototypes are:\n    FIX::PriceUnitOfMeasure()\n    FIX::PriceUnitOfMeasure(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TZTransactTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TZTIMESTAMP *arg1 = 0 ;
  FIX::TZTransactTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TZTransactTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TZTransactTime__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TZTransactTime'.\n  Possible C/C++ prototypes are:\n    FIX::TZTransactTime()\n    FIX::TZTransactTime(FIX::TZTIMESTAMP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocHandlInst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::AllocHandlInst *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocHandlInst(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllocHandlInst__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllocHandlInst'.\n  Possible C/C++ prototypes are:\n    FIX::AllocHandlInst()\n    FIX::AllocHandlInst(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingInstrumentPartyIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::UnderlyingInstrumentPartyIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingInstrumentPartyIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingInstrumentPartyIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingInstrumentPartyIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingInstrumentPartyIDSource()\n    FIX::UnderlyingInstrumentPartyIDSource(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CurrencyRatio__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::CurrencyRatio *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CurrencyRatio(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CurrencyRatio__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CurrencyRatio'.\n  Possible C/C++ prototypes are:\n    FIX::CurrencyRatio()\n    FIX::CurrencyRatio(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefreshQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::RefreshQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefreshQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RefreshQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RefreshQty'.\n  Possible C/C++ prototypes are:\n    FIX::RefreshQty()\n    FIX::RefreshQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeRequestStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TradeRequestStatus *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeRequestStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradeRequestStatus__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradeRequestStatus'.\n  Possible C/C++ prototypes are:\n    FIX::TradeRequestStatus()\n    FIX::TradeRequestStatus(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdRepIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::TrdRepIndicator *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdRepIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TrdRepIndicator__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TrdRepIndicator'.\n  Possible C/C++ prototypes are:\n    FIX::TrdRepIndicator()\n    FIX::TrdRepIndicator(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MiscFeeAmt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::MiscFeeAmt *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MiscFeeAmt(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MiscFeeAmt__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MiscFeeAmt'.\n  Possible C/C++ prototypes are:\n    FIX::MiscFeeAmt()\n    FIX::MiscFeeAmt(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesOpenTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  FIX::TradSesOpenTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesOpenTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  FIX::TradSesOpenTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesOpenTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  FIX::TradSesOpenTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesOpenTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_new_TradSesOpenTime__SWIG_3(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradSesOpenTime'.\n  Possible C/C++ prototypes are:\n    FIX::TradSesOpenTime()\n    FIX::TradSesOpenTime(bool)\n    FIX::TradSesOpenTime(FIX::UTCTIMESTAMP const &)\n    FIX::TradSesOpenTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PreallocMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::PreallocMethod *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PreallocMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PreallocMethod__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PreallocMethod'.\n  Possible C/C++ prototypes are:\n    FIX::PreallocMethod()\n    FIX::PreallocMethod(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TaxAdvantageType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TaxAdvantageType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TaxAdvantageType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TaxAdvantageType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TaxAdvantageType'.\n  Possible C/C++ prototypes are:\n    FIX::TaxAdvantageType()\n    FIX::TaxAdvantageType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MessageEncoding__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::MessageEncoding *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MessageEncoding(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MessageEncoding__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MessageEncoding'.\n  Possible C/C++ prototypes are:\n    FIX::MessageEncoding()\n    FIX::MessageEncoding(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RiskPutOrCall__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskPutOrCall *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RiskPutOrCall")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskPutOrCall *)new FIX::RiskPutOrCall();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskPutOrCall, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RiskPutOrCall(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RiskPutOrCall__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskPutOrCall__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskPutOrCall'.\n  Possible C/C++ prototypes are:\n    FIX::RiskPutOrCall()\n    FIX::RiskPutOrCall(FIX::INT const &)\n");
  return NULL;
}


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


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

SWIGINTERN PyObject *_wrap_new_RiskSecurityGroup__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskSecurityGroup *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RiskSecurityGroup")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskSecurityGroup *)new FIX::RiskSecurityGroup();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskSecurityGroup, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RiskSecurityGroup(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RiskSecurityGroup__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskSecurityGroup__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskSecurityGroup'.\n  Possible C/C++ prototypes are:\n    FIX::RiskSecurityGroup()\n    FIX::RiskSecurityGroup(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RiskSecurityGroup_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RiskSecurityGroup, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoPartySubIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoPartySubIDs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoPartySubIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoPartySubIDs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoPartySubIDs'.\n  Possible C/C++ prototypes are:\n    FIX::NoPartySubIDs()\n    FIX::NoPartySubIDs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SettlInstReqID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlInstReqID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlInstReqID'.\n  Possible C/C++ prototypes are:\n    FIX::SettlInstReqID()\n    FIX::SettlInstReqID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_LegRepoCollateralSecurityType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_LegRepoCollateralSecurityType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegRepoCollateralSecurityType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegRepoCollateralSecurityType'.\n  Possible C/C++ prototypes are:\n    FIX::LegRepoCollateralSecurityType()\n    FIX::LegRepoCollateralSecurityType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AffectedSecondaryOrderID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::AffectedSecondaryOrderID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AffectedSecondaryOrderID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AffectedSecondaryOrderID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AffectedSecondaryOrderID'.\n  Possible C/C++ prototypes are:\n    FIX::AffectedSecondaryOrderID()\n    FIX::AffectedSecondaryOrderID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RiskSymbol__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskSymbol *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RiskSymbol")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskSymbol *)new FIX::RiskSymbol();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskSymbol, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RiskSymbol(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RiskSymbol__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskSymbol__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskSymbol'.\n  Possible C/C++ prototypes are:\n    FIX::RiskSymbol()\n    FIX::RiskSymbol(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RiskSymbol_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RiskSymbol, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeMaturityTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TZTIMEONLY *arg1 = 0 ;
  FIX::DerivativeMaturityTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeMaturityTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeMaturityTime__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeMaturityTime'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeMaturityTime()\n    FIX::DerivativeMaturityTime(FIX::TZTIMEONLY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExpireTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  FIX::ExpireTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExpireTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  FIX::ExpireTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExpireTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  FIX::ExpireTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExpireTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_new_ExpireTime__SWIG_3(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ExpireTime'.\n  Possible C/C++ prototypes are:\n    FIX::ExpireTime()\n    FIX::ExpireTime(bool)\n    FIX::ExpireTime(FIX::UTCTIMESTAMP const &)\n    FIX::ExpireTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingFactor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::UnderlyingFactor *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingFactor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingFactor__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingFactor'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingFactor()\n    FIX::UnderlyingFactor(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigOrdModTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  FIX::OrigOrdModTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigOrdModTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  FIX::OrigOrdModTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigOrdModTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  FIX::OrigOrdModTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigOrdModTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_new_OrigOrdModTime__SWIG_3(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OrigOrdModTime'.\n  Possible C/C++ prototypes are:\n    FIX::OrigOrdModTime()\n    FIX::OrigOrdModTime(bool)\n    FIX::OrigOrdModTime(FIX::UTCTIMESTAMP const &)\n    FIX::OrigOrdModTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTrdRepIndicators__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoTrdRepIndicators *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTrdRepIndicators(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoTrdRepIndicators__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoTrdRepIndicators'.\n  Possible C/C++ prototypes are:\n    FIX::NoTrdRepIndicators()\n    FIX::NoTrdRepIndicators(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeMaturityDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::DerivativeMaturityDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeMaturityDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeMaturityDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeMaturityDate'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeMaturityDate()\n    FIX::DerivativeMaturityDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeCFICode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DerivativeCFICode *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeCFICode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeCFICode__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeCFICode'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeCFICode()\n    FIX::DerivativeCFICode(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested2PartySubIDType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::Nested2PartySubIDType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested2PartySubIDType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Nested2PartySubIDType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Nested2PartySubIDType'.\n  Possible C/C++ prototypes are:\n    FIX::Nested2PartySubIDType()\n    FIX::Nested2PartySubIDType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegIOIQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LegIOIQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegIOIQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegIOIQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegIOIQty'.\n  Possible C/C++ prototypes are:\n    FIX::LegIOIQty()\n    FIX::LegIOIQty(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExpireDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::ExpireDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExpireDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ExpireDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ExpireDate'.\n  Possible C/C++ prototypes are:\n    FIX::ExpireDate()\n    FIX::ExpireDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RiskSecurityType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskSecurityType *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RiskSecurityType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskSecurityType *)new FIX::RiskSecurityType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskSecurityType, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RiskSecurityType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RiskSecurityType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskSecurityType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskSecurityType'.\n  Possible C/C++ prototypes are:\n    FIX::RiskSecurityType()\n    FIX::RiskSecurityType(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RiskSecurityType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RiskSecurityType, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoMatchRules__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoMatchRules *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoMatchRules(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoMatchRules__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoMatchRules'.\n  Possible C/C++ prototypes are:\n    FIX::NoMatchRules()\n    FIX::NoMatchRules(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplEndSeqNum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SEQNUM *arg1 = 0 ;
  FIX::ApplEndSeqNum *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplEndSeqNum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ApplEndSeqNum__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ApplEndSeqNum'.\n  Possible C/C++ prototypes are:\n    FIX::ApplEndSeqNum()\n    FIX::ApplEndSeqNum(FIX::SEQNUM const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EventPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::EventPx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EventPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EventPx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EventPx'.\n  Possible C/C++ prototypes are:\n    FIX::EventPx()\n    FIX::EventPx(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AsgnRptID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::AsgnRptID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AsgnRptID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AsgnRptID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AsgnRptID'.\n  Possible C/C++ prototypes are:\n    FIX::AsgnRptID()\n    FIX::AsgnRptID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeInForce__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::TimeInForce *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeInForce(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TimeInForce__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TimeInForce'.\n  Possible C/C++ prototypes are:\n    FIX::TimeInForce()\n    FIX::TimeInForce(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LowPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::LowPx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LowPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LowPx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LowPx'.\n  Possible C/C++ prototypes are:\n    FIX::LowPx()\n    FIX::LowPx(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOIQualifier__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::IOIQualifier *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOIQualifier(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_IOIQualifier__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_IOIQualifier'.\n  Possible C/C++ prototypes are:\n    FIX::IOIQualifier()\n    FIX::IOIQualifier(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WaveNo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::WaveNo *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WaveNo(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_WaveNo__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_WaveNo'.\n  Possible C/C++ prototypes are:\n    FIX::WaveNo()\n    FIX::WaveNo(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RiskSeniority__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskSeniority *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RiskSeniority")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskSeniority *)new FIX::RiskSeniority();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskSeniority, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RiskSeniority(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RiskSeniority__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskSeniority__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskSeniority'.\n  Possible C/C++ prototypes are:\n    FIX::RiskSeniority()\n    FIX::RiskSeniority(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RiskSeniority_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RiskSeniority, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikePriceBoundaryMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::StrikePriceBoundaryMethod *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikePriceBoundaryMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StrikePriceBoundaryMethod__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StrikePriceBoundaryMethod'.\n  Possible C/C++ prototypes are:\n    FIX::StrikePriceBoundaryMethod()\n    FIX::StrikePriceBoundaryMethod(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeIssueDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::DerivativeIssueDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeIssueDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeIssueDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeIssueDate'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeIssueDate()\n    FIX::DerivativeIssueDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MiscFeeType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::MiscFeeType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MiscFeeType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MiscFeeType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MiscFeeType'.\n  Possible C/C++ prototypes are:\n    FIX::MiscFeeType()\n    FIX::MiscFeeType(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::QuoteID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_QuoteID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_QuoteID'.\n  Possible C/C++ prototypes are:\n    FIX::QuoteID()\n    FIX::QuoteID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RiskFlexibleIndicator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskFlexibleIndicator *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RiskFlexibleIndicator")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskFlexibleIndicator *)new FIX::RiskFlexibleIndicator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskFlexibleIndicator, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RiskFlexibleIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::RiskFlexibleIndicator *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_RiskFlexibleIndicator",&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_RiskFlexibleIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RiskFlexibleIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskFlexibleIndicator *)new FIX::RiskFlexibleIndicator((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskFlexibleIndicator, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RiskFlexibleIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RiskFlexibleIndicator__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskFlexibleIndicator__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskFlexibleIndicator'.\n  Possible C/C++ prototypes are:\n    FIX::RiskFlexibleIndicator()\n    FIX::RiskFlexibleIndicator(FIX::BOOLEAN const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RiskFlexibleIndicator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RiskFlexibleIndicator, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrumentPartyIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DerivativeInstrumentPartyIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrumentPartyIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeInstrumentPartyIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeInstrumentPartyIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeInstrumentPartyIDSource()\n    FIX::DerivativeInstrumentPartyIDSource(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlObligID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SettlObligID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlObligID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlObligID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlObligID'.\n  Possible C/C++ prototypes are:\n    FIX::SettlObligID()\n    FIX::SettlObligID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrAttribValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::InstrAttribValue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrAttribValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_InstrAttribValue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_InstrAttribValue'.\n  Possible C/C++ prototypes are:\n    FIX::InstrAttribValue()\n    FIX::InstrAttribValue(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LiquidityValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::LiquidityValue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LiquidityValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LiquidityValue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LiquidityValue'.\n  Possible C/C++ prototypes are:\n    FIX::LiquidityValue()\n    FIX::LiquidityValue(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SecurityIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecurityIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecurityIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::SecurityIDSource()\n    FIX::SecurityIDSource(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NewsRefType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::NewsRefType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NewsRefType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NewsRefType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NewsRefType'.\n  Possible C/C++ prototypes are:\n    FIX::NewsRefType()\n    FIX::NewsRefType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoOfLegUnderlyings__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoOfLegUnderlyings *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoOfLegUnderlyings(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoOfLegUnderlyings__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoOfLegUnderlyings'.\n  Possible C/C++ prototypes are:\n    FIX::NoOfLegUnderlyings()\n    FIX::NoOfLegUnderlyings(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEncodedSecurityDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  FIX::DerivativeEncodedSecurityDesc *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEncodedSecurityDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeEncodedSecurityDesc__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeEncodedSecurityDesc'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeEncodedSecurityDesc()\n    FIX::DerivativeEncodedSecurityDesc(FIX::DATA const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerOrderType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::TriggerOrderType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerOrderType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TriggerOrderType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TriggerOrderType'.\n  Possible C/C++ prototypes are:\n    FIX::TriggerOrderType()\n    FIX::TriggerOrderType(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingDirtyPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::UnderlyingDirtyPrice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingDirtyPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingDirtyPrice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingDirtyPrice'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingDirtyPrice()\n    FIX::UnderlyingDirtyPrice(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CrossType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::CrossType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CrossType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CrossType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CrossType'.\n  Possible C/C++ prototypes are:\n    FIX::CrossType()\n    FIX::CrossType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RepoCollateralSecurityType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RepoCollateralSecurityType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RepoCollateralSecurityType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RepoCollateralSecurityType'.\n  Possible C/C++ prototypes are:\n    FIX::RepoCollateralSecurityType()\n    FIX::RepoCollateralSecurityType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Password__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::Password *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Password(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Password__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Password'.\n  Possible C/C++ prototypes are:\n    FIX::Password()\n    FIX::Password(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OpenCloseSettleFlag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MULTIPLEVALUESTRING *arg1 = 0 ;
  FIX::OpenCloseSettleFlag *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OpenCloseSettleFlag(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OpenCloseSettleFlag__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OpenCloseSettleFlag'.\n  Possible C/C++ prototypes are:\n    FIX::OpenCloseSettleFlag()\n    FIX::OpenCloseSettleFlag(FIX::MULTIPLEVALUESTRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Subject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::Subject *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Subject(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Subject__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Subject'.\n  Possible C/C++ prototypes are:\n    FIX::Subject()\n    FIX::Subject(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefApplReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::RefApplReqID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefApplReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RefApplReqID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RefApplReqID'.\n  Possible C/C++ prototypes are:\n    FIX::RefApplReqID()\n    FIX::RefApplReqID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingEndValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::UnderlyingEndValue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingEndValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingEndValue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingEndValue'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingEndValue()\n    FIX::UnderlyingEndValue(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NewSeqNo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SEQNUM *arg1 = 0 ;
  FIX::NewSeqNo *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NewSeqNo(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NewSeqNo__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NewSeqNo'.\n  Possible C/C++ prototypes are:\n    FIX::NewSeqNo()\n    FIX::NewSeqNo(FIX::SEQNUM const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigTradeHandlingInstr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::OrigTradeHandlingInstr *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigTradeHandlingInstr(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OrigTradeHandlingInstr__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OrigTradeHandlingInstr'.\n  Possible C/C++ prototypes are:\n    FIX::OrigTradeHandlingInstr()\n    FIX::OrigTradeHandlingInstr(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DisplayHighQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::DisplayHighQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DisplayHighQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DisplayHighQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DisplayHighQty'.\n  Possible C/C++ prototypes are:\n    FIX::DisplayHighQty()\n    FIX::DisplayHighQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDBookType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::MDBookType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDBookType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MDBookType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MDBookType'.\n  Possible C/C++ prototypes are:\n    FIX::MDBookType()\n    FIX::MDBookType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarginExcess__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::MarginExcess *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarginExcess(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MarginExcess__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MarginExcess'.\n  Possible C/C++ prototypes are:\n    FIX::MarginExcess()\n    FIX::MarginExcess(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BasisPxType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::BasisPxType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BasisPxType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_BasisPxType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BasisPxType'.\n  Possible C/C++ prototypes are:\n    FIX::BasisPxType()\n    FIX::BasisPxType(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DlvyInst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DlvyInst *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DlvyInst(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DlvyInst__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DlvyInst'.\n  Possible C/C++ prototypes are:\n    FIX::DlvyInst()\n    FIX::DlvyInst(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplianceID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ComplianceID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplianceID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ComplianceID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ComplianceID'.\n  Possible C/C++ prototypes are:\n    FIX::ComplianceID()\n    FIX::ComplianceID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EmailThreadID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::EmailThreadID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EmailThreadID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EmailThreadID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EmailThreadID'.\n  Possible C/C++ prototypes are:\n    FIX::EmailThreadID()\n    FIX::EmailThreadID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContAmtCurr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  FIX::ContAmtCurr *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContAmtCurr(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ContAmtCurr__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ContAmtCurr'.\n  Possible C/C++ prototypes are:\n    FIX::ContAmtCurr()\n    FIX::ContAmtCurr(FIX::CURRENCY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelationshipRiskSecurityGroup__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelationshipRiskSecurityGroup *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelationshipRiskSecurityGroup")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskSecurityGroup *)new FIX::RelationshipRiskSecurityGroup();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskSecurityGroup, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RelationshipRiskSecurityGroup(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelationshipRiskSecurityGroup__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelationshipRiskSecurityGroup__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelationshipRiskSecurityGroup'.\n  Possible C/C++ prototypes are:\n    FIX::RelationshipRiskSecurityGroup()\n    FIX::RelationshipRiskSecurityGroup(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelationshipRiskSecurityGroup_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelationshipRiskSecurityGroup, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ComplexEventType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ComplexEventType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ComplexEventType'.\n  Possible C/C++ prototypes are:\n    FIX::ComplexEventType()\n    FIX::ComplexEventType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassActionResponse__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::MassActionResponse *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassActionResponse(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MassActionResponse__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MassActionResponse'.\n  Possible C/C++ prototypes are:\n    FIX::MassActionResponse()\n    FIX::MassActionResponse(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingIssueDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::UnderlyingIssueDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingIssueDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingIssueDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingIssueDate'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingIssueDate()\n    FIX::UnderlyingIssueDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityRequestType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::SecurityRequestType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityRequestType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecurityRequestType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecurityRequestType'.\n  Possible C/C++ prototypes are:\n    FIX::SecurityRequestType()\n    FIX::SecurityRequestType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocInterestAtMaturity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::AllocInterestAtMaturity *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocInterestAtMaturity(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllocInterestAtMaturity__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllocInterestAtMaturity'.\n  Possible C/C++ prototypes are:\n    FIX::AllocInterestAtMaturity()\n    FIX::AllocInterestAtMaturity(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListRejectReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ListRejectReason *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListRejectReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ListRejectReason__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ListRejectReason'.\n  Possible C/C++ prototypes are:\n    FIX::ListRejectReason()\n    FIX::ListRejectReason(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeskType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DeskType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeskType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DeskType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DeskType'.\n  Possible C/C++ prototypes are:\n    FIX::DeskType()\n    FIX::DeskType(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryTradeReportID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SecondaryTradeReportID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryTradeReportID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecondaryTradeReportID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecondaryTradeReportID'.\n  Possible C/C++ prototypes are:\n    FIX::SecondaryTradeReportID()\n    FIX::SecondaryTradeReportID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SettlType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlType'.\n  Possible C/C++ prototypes are:\n    FIX::SettlType()\n    FIX::SettlType(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OpenClose__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::OpenClose *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OpenClose(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OpenClose__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OpenClose'.\n  Possible C/C++ prototypes are:\n    FIX::OpenClose()\n    FIX::OpenClose(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContractMultiplierUnit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ContractMultiplierUnit *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContractMultiplierUnit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ContractMultiplierUnit__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ContractMultiplierUnit'.\n  Possible C/C++ prototypes are:\n    FIX::ContractMultiplierUnit()\n    FIX::ContractMultiplierUnit(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryLowLimitPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::SecondaryLowLimitPrice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryLowLimitPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecondaryLowLimitPrice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecondaryLowLimitPrice'.\n  Possible C/C++ prototypes are:\n    FIX::SecondaryLowLimitPrice()\n    FIX::SecondaryLowLimitPrice(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExpQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::ExpQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExpQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ExpQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ExpQty'.\n  Possible C/C++ prototypes are:\n    FIX::ExpQty()\n    FIX::ExpQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetworkRequestID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::NetworkRequestID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetworkRequestID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NetworkRequestID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NetworkRequestID'.\n  Possible C/C++ prototypes are:\n    FIX::NetworkRequestID()\n    FIX::NetworkRequestID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TrdType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TrdType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TrdType'.\n  Possible C/C++ prototypes are:\n    FIX::TrdType()\n    FIX::TrdType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoUnderlyings__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoUnderlyings *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoUnderlyings(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoUnderlyings__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoUnderlyings'.\n  Possible C/C++ prototypes are:\n    FIX::NoUnderlyings()\n    FIX::NoUnderlyings(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDMkt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EXCHANGE *arg1 = 0 ;
  FIX::MDMkt *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDMkt(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MDMkt__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MDMkt'.\n  Possible C/C++ prototypes are:\n    FIX::MDMkt()\n    FIX::MDMkt(FIX::EXCHANGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastMkt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EXCHANGE *arg1 = 0 ;
  FIX::LastMkt *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastMkt(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LastMkt__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LastMkt'.\n  Possible C/C++ prototypes are:\n    FIX::LastMkt()\n    FIX::LastMkt(FIX::EXCHANGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RestructuringType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::RestructuringType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RestructuringType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RestructuringType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RestructuringType'.\n  Possible C/C++ prototypes are:\n    FIX::RestructuringType()\n    FIX::RestructuringType(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoStrikeRules__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoStrikeRules *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoStrikeRules(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoStrikeRules__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoStrikeRules'.\n  Possible C/C++ prototypes are:\n    FIX::NoStrikeRules()\n    FIX::NoStrikeRules(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ListName *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListName(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ListName__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ListName'.\n  Possible C/C++ prototypes are:\n    FIX::ListName()\n    FIX::ListName(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ProgRptReqs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ProgRptReqs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ProgRptReqs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ProgRptReqs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ProgRptReqs'.\n  Possible C/C++ prototypes are:\n    FIX::ProgRptReqs()\n    FIX::ProgRptReqs(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradingSessionID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::TradingSessionID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradingSessionID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradingSessionID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradingSessionID'.\n  Possible C/C++ prototypes are:\n    FIX::TradingSessionID()\n    FIX::TradingSessionID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOrderStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ListOrderStatus *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOrderStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ListOrderStatus__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ListOrderStatus'.\n  Possible C/C++ prototypes are:\n    FIX::ListOrderStatus()\n    FIX::ListOrderStatus(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::RegistStatus *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RegistStatus__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RegistStatus'.\n  Possible C/C++ prototypes are:\n    FIX::RegistStatus()\n    FIX::RegistStatus(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosAmt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::PosAmt *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosAmt(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PosAmt__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PosAmt'.\n  Possible C/C++ prototypes are:\n    FIX::PosAmt()\n    FIX::PosAmt(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingPriceDeterminationMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::UnderlyingPriceDeterminationMethod *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingPriceDeterminationMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingPriceDeterminationMethod__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingPriceDeterminationMethod'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingPriceDeterminationMethod()\n    FIX::UnderlyingPriceDeterminationMethod(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoUnderlyingStips__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoUnderlyingStips *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoUnderlyingStips(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoUnderlyingStips__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoUnderlyingStips'.\n  Possible C/C++ prototypes are:\n    FIX::NoUnderlyingStips()\n    FIX::NoUnderlyingStips(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesPreCloseTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  FIX::TradSesPreCloseTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesPreCloseTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  FIX::TradSesPreCloseTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesPreCloseTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  FIX::TradSesPreCloseTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesPreCloseTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_new_TradSesPreCloseTime__SWIG_3(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradSesPreCloseTime'.\n  Possible C/C++ prototypes are:\n    FIX::TradSesPreCloseTime()\n    FIX::TradSesPreCloseTime(bool)\n    FIX::TradSesPreCloseTime(FIX::UTCTIMESTAMP const &)\n    FIX::TradSesPreCloseTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassCancelRequestType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::MassCancelRequestType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassCancelRequestType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MassCancelRequestType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MassCancelRequestType'.\n  Possible C/C++ prototypes are:\n    FIX::MassCancelRequestType()\n    FIX::MassCancelRequestType(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityAltIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingLegSecurityAltIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityAltIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingLegSecurityAltIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingLegSecurityAltIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingLegSecurityAltIDSource()\n    FIX::UnderlyingLegSecurityAltIDSource(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlPartyID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SettlPartyID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlPartyID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlPartyID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlPartyID'.\n  Possible C/C++ prototypes are:\n    FIX::SettlPartyID()\n    FIX::SettlPartyID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoAffectedOrders__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoAffectedOrders *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoAffectedOrders(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoAffectedOrders__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoAffectedOrders'.\n  Possible C/C++ prototypes are:\n    FIX::NoAffectedOrders()\n    FIX::NoAffectedOrders(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashSettlAgentAcctNum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::CashSettlAgentAcctNum *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashSettlAgentAcctNum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CashSettlAgentAcctNum__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CashSettlAgentAcctNum'.\n  Possible C/C++ prototypes are:\n    FIX::CashSettlAgentAcctNum()\n    FIX::CashSettlAgentAcctNum(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegMaturityMonthYear__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MONTHYEAR *arg1 = 0 ;
  FIX::UnderlyingLegMaturityMonthYear *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegMaturityMonthYear(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingLegMaturityMonthYear__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingLegMaturityMonthYear'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingLegMaturityMonthYear()\n    FIX::UnderlyingLegMaturityMonthYear(FIX::MONTHYEAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_DerivativeSecurityListRequestType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSecurityListRequestType *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeSecurityListRequestType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSecurityListRequestType *)new FIX::DerivativeSecurityListRequestType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSecurityListRequestType, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityListRequestType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_DerivativeSecurityListRequestType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeSecurityListRequestType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeSecurityListRequestType'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeSecurityListRequestType()\n    FIX::DerivativeSecurityListRequestType(FIX::INT const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *DerivativeSecurityListRequestType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeSecurityListRequestType, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoLotTypeRules__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoLotTypeRules *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoLotTypeRules(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoLotTypeRules__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoLotTypeRules'.\n  Possible C/C++ prototypes are:\n    FIX::NoLotTypeRules()\n    FIX::NoLotTypeRules(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_NoDates(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_NoDates__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoDates__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoDates'.\n  Possible C/C++ prototypes are:\n    FIX::NoDates()\n    FIX::NoDates(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CxlRejResponseTo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::CxlRejResponseTo *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CxlRejResponseTo(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CxlRejResponseTo__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CxlRejResponseTo'.\n  Possible C/C++ prototypes are:\n    FIX::CxlRejResponseTo()\n    FIX::CxlRejResponseTo(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EffectiveTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  FIX::EffectiveTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EffectiveTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  FIX::EffectiveTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EffectiveTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  FIX::EffectiveTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EffectiveTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_new_EffectiveTime__SWIG_3(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EffectiveTime'.\n  Possible C/C++ prototypes are:\n    FIX::EffectiveTime()\n    FIX::EffectiveTime(bool)\n    FIX::EffectiveTime(FIX::UTCTIMESTAMP const &)\n    FIX::EffectiveTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GrossTradeAmt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::GrossTradeAmt *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GrossTradeAmt(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_GrossTradeAmt__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_GrossTradeAmt'.\n  Possible C/C++ prototypes are:\n    FIX::GrossTradeAmt()\n    FIX::GrossTradeAmt(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_ContextPartyID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContextPartyID *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_ContextPartyID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContextPartyID *)new FIX::ContextPartyID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContextPartyID, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_ContextPartyID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_ContextPartyID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ContextPartyID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ContextPartyID'.\n  Possible C/C++ prototypes are:\n    FIX::ContextPartyID()\n    FIX::ContextPartyID(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *ContextPartyID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ContextPartyID, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityListDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SecurityListDesc *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityListDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecurityListDesc__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecurityListDesc'.\n  Possible C/C++ prototypes are:\n    FIX::SecurityListDesc()\n    FIX::SecurityListDesc(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NotAffectedOrderID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::NotAffectedOrderID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NotAffectedOrderID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NotAffectedOrderID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NotAffectedOrderID'.\n  Possible C/C++ prototypes are:\n    FIX::NotAffectedOrderID()\n    FIX::NotAffectedOrderID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeStrikeValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::DerivativeStrikeValue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeStrikeValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeStrikeValue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeStrikeValue'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeStrikeValue()\n    FIX::DerivativeStrikeValue(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoPosAmt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoPosAmt *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoPosAmt(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoPosAmt__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoPosAmt'.\n  Possible C/C++ prototypes are:\n    FIX::NoPosAmt()\n    FIX::NoPosAmt(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCreditRating__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LegCreditRating *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCreditRating(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegCreditRating__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegCreditRating'.\n  Possible C/C++ prototypes are:\n    FIX::LegCreditRating()\n    FIX::LegCreditRating(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelationshipRiskInstrumentSettlType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelationshipRiskInstrumentSettlType *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelationshipRiskInstrumentSettlType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskInstrumentSettlType *)new FIX::RelationshipRiskInstrumentSettlType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskInstrumentSettlType, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RelationshipRiskInstrumentSettlType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelationshipRiskInstrumentSettlType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelationshipRiskInstrumentSettlType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelationshipRiskInstrumentSettlType'.\n  Possible C/C++ prototypes are:\n    FIX::RelationshipRiskInstrumentSettlType()\n    FIX::RelationshipRiskInstrumentSettlType(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelationshipRiskInstrumentSettlType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelationshipRiskInstrumentSettlType, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidForwardPoints2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  FIX::BidForwardPoints2 *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidForwardPoints2(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_BidForwardPoints2__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BidForwardPoints2'.\n  Possible C/C++ prototypes are:\n    FIX::BidForwardPoints2()\n    FIX::BidForwardPoints2(FIX::PRICEOFFSET const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::SettlDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlDate'.\n  Possible C/C++ prototypes are:\n    FIX::SettlDate()\n    FIX::SettlDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClientID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ClientID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClientID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ClientID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ClientID'.\n  Possible C/C++ prototypes are:\n    FIX::ClientID()\n    FIX::ClientID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteCancelType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::QuoteCancelType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteCancelType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_QuoteCancelType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_QuoteCancelType'.\n  Possible C/C++ prototypes are:\n    FIX::QuoteCancelType()\n    FIX::QuoteCancelType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StipulationType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::StipulationType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StipulationType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StipulationType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StipulationType'.\n  Possible C/C++ prototypes are:\n    FIX::StipulationType()\n    FIX::StipulationType(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OutMainCntryUIndex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::OutMainCntryUIndex *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OutMainCntryUIndex(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OutMainCntryUIndex__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OutMainCntryUIndex'.\n  Possible C/C++ prototypes are:\n    FIX::OutMainCntryUIndex()\n    FIX::OutMainCntryUIndex(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSettlmntTyp__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::LegSettlmntTyp *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSettlmntTyp(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegSettlmntTyp__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegSettlmntTyp'.\n  Possible C/C++ prototypes are:\n    FIX::LegSettlmntTyp()\n    FIX::LegSettlmntTyp(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_NoRelationshipRiskInstruments__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoRelationshipRiskInstruments *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_NoRelationshipRiskInstruments")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRelationshipRiskInstruments *)new FIX::NoRelationshipRiskInstruments();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRelationshipRiskInstruments, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRelationshipRiskInstruments__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRelationshipRiskInstruments *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoRelationshipRiskInstruments",&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_NoRelationshipRiskInstruments" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoRelationshipRiskInstruments" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRelationshipRiskInstruments *)new FIX::NoRelationshipRiskInstruments((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRelationshipRiskInstruments, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRelationshipRiskInstruments(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_NoRelationshipRiskInstruments__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoRelationshipRiskInstruments__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoRelationshipRiskInstruments'.\n  Possible C/C++ prototypes are:\n    FIX::NoRelationshipRiskInstruments()\n    FIX::NoRelationshipRiskInstruments(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *NoRelationshipRiskInstruments_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoRelationshipRiskInstruments, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeNTPositionLimit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::DerivativeNTPositionLimit *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeNTPositionLimit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeNTPositionLimit__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeNTPositionLimit'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeNTPositionLimit()\n    FIX::DerivativeNTPositionLimit(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriceQuoteMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::PriceQuoteMethod *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriceQuoteMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PriceQuoteMethod__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PriceQuoteMethod'.\n  Possible C/C++ prototypes are:\n    FIX::PriceQuoteMethod()\n    FIX::PriceQuoteMethod(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LowLimitPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::LowLimitPrice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LowLimitPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LowLimitPrice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LowLimitPrice'.\n  Possible C/C++ prototypes are:\n    FIX::LowLimitPrice()\n    FIX::LowLimitPrice(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegUnitOfMeasure__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LegUnitOfMeasure *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegUnitOfMeasure(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegUnitOfMeasure__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegUnitOfMeasure'.\n  Possible C/C++ prototypes are:\n    FIX::LegUnitOfMeasure()\n    FIX::LegUnitOfMeasure(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionRejectReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::SessionRejectReason *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionRejectReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SessionRejectReason__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SessionRejectReason'.\n  Possible C/C++ prototypes are:\n    FIX::SessionRejectReason()\n    FIX::SessionRejectReason(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_PartyDetailsListReportID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PartyDetailsListReportID *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_PartyDetailsListReportID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PartyDetailsListReportID *)new FIX::PartyDetailsListReportID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PartyDetailsListReportID, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_PartyDetailsListReportID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_PartyDetailsListReportID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PartyDetailsListReportID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PartyDetailsListReportID'.\n  Possible C/C++ prototypes are:\n    FIX::PartyDetailsListReportID()\n    FIX::PartyDetailsListReportID(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *PartyDetailsListReportID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PartyDetailsListReportID, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeliveryType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::DeliveryType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeliveryType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DeliveryType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DeliveryType'.\n  Possible C/C++ prototypes are:\n    FIX::DeliveryType()\n    FIX::DeliveryType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::AllocPrice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllocPrice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllocPrice'.\n  Possible C/C++ prototypes are:\n    FIX::AllocPrice()\n    FIX::AllocPrice(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoBidComponents__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoBidComponents *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoBidComponents(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoBidComponents__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoBidComponents'.\n  Possible C/C++ prototypes are:\n    FIX::NoBidComponents()\n    FIX::NoBidComponents(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteQualifier__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::QuoteQualifier *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteQualifier(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_QuoteQualifier__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_QuoteQualifier'.\n  Possible C/C++ prototypes are:\n    FIX::QuoteQualifier()\n    FIX::QuoteQualifier(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Scope__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MULTIPLECHARVALUE *arg1 = 0 ;
  FIX::Scope *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Scope(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Scope__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Scope'.\n  Possible C/C++ prototypes are:\n    FIX::Scope()\n    FIX::Scope(FIX::MULTIPLECHARVALUE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSecurityAltID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoSecurityAltID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSecurityAltID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoSecurityAltID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoSecurityAltID'.\n  Possible C/C++ prototypes are:\n    FIX::NoSecurityAltID()\n    FIX::NoSecurityAltID(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RootPartySubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::RootPartySubID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RootPartySubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RootPartySubID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RootPartySubID'.\n  Possible C/C++ prototypes are:\n    FIX::RootPartySubID()\n    FIX::RootPartySubID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeliverToLocationID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DeliverToLocationID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeliverToLocationID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DeliverToLocationID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DeliverToLocationID'.\n  Possible C/C++ prototypes are:\n    FIX::DeliverToLocationID()\n    FIX::DeliverToLocationID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeleteReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::DeleteReason *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeleteReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DeleteReason__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DeleteReason'.\n  Possible C/C++ prototypes are:\n    FIX::DeleteReason()\n    FIX::DeleteReason(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidSpotRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::BidSpotRate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidSpotRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_BidSpotRate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BidSpotRate'.\n  Possible C/C++ prototypes are:\n    FIX::BidSpotRate()\n    FIX::BidSpotRate(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested4PartyID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::Nested4PartyID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested4PartyID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Nested4PartyID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Nested4PartyID'.\n  Possible C/C++ prototypes are:\n    FIX::Nested4PartyID()\n    FIX::Nested4PartyID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InViewOfCommon__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::InViewOfCommon *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InViewOfCommon(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_InViewOfCommon__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_InViewOfCommon'.\n  Possible C/C++ prototypes are:\n    FIX::InViewOfCommon()\n    FIX::InViewOfCommon(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSettlPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::UnderlyingSettlPrice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSettlPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingSettlPrice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingSettlPrice'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingSettlPrice()\n    FIX::UnderlyingSettlPrice(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistRejReasonText__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::RegistRejReasonText *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistRejReasonText(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RegistRejReasonText__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RegistRejReasonText'.\n  Possible C/C++ prototypes are:\n    FIX::RegistRejReasonText()\n    FIX::RegistRejReasonText(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSides__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoSides *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSides(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoSides__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoSides'.\n  Possible C/C++ prototypes are:\n    FIX::NoSides()\n    FIX::NoSides(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegAllocAccount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LegAllocAccount *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegAllocAccount(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegAllocAccount__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegAllocAccount'.\n  Possible C/C++ prototypes are:\n    FIX::LegAllocAccount()\n    FIX::LegAllocAccount(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_NoRelationshipRiskWarningLevels__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoRelationshipRiskWarningLevels *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_NoRelationshipRiskWarningLevels")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRelationshipRiskWarningLevels *)new FIX::NoRelationshipRiskWarningLevels();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRelationshipRiskWarningLevels, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRelationshipRiskWarningLevels__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRelationshipRiskWarningLevels *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoRelationshipRiskWarningLevels",&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_NoRelationshipRiskWarningLevels" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoRelationshipRiskWarningLevels" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRelationshipRiskWarningLevels *)new FIX::NoRelationshipRiskWarningLevels((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRelationshipRiskWarningLevels, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRelationshipRiskWarningLevels(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_NoRelationshipRiskWarningLevels__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoRelationshipRiskWarningLevels__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoRelationshipRiskWarningLevels'.\n  Possible C/C++ prototypes are:\n    FIX::NoRelationshipRiskWarningLevels()\n    FIX::NoRelationshipRiskWarningLevels(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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


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

SWIGINTERN PyObject *_wrap_new_RelationshipRiskProduct__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelationshipRiskProduct *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelationshipRiskProduct")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskProduct *)new FIX::RelationshipRiskProduct();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskProduct, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RelationshipRiskProduct(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelationshipRiskProduct__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelationshipRiskProduct__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelationshipRiskProduct'.\n  Possible C/C++ prototypes are:\n    FIX::RelationshipRiskProduct()\n    FIX::RelationshipRiskProduct(FIX::INT const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelationshipRiskProduct_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelationshipRiskProduct, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSecurityDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LegSecurityDesc *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSecurityDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegSecurityDesc__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegSecurityDesc'.\n  Possible C/C++ prototypes are:\n    FIX::LegSecurityDesc()\n    FIX::LegSecurityDesc(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClOrdLinkID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ClOrdLinkID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClOrdLinkID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ClOrdLinkID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ClOrdLinkID'.\n  Possible C/C++ prototypes are:\n    FIX::ClOrdLinkID()\n    FIX::ClOrdLinkID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigSendingTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  FIX::OrigSendingTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigSendingTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  FIX::OrigSendingTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigSendingTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  FIX::OrigSendingTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigSendingTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_new_OrigSendingTime__SWIG_3(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OrigSendingTime'.\n  Possible C/C++ prototypes are:\n    FIX::OrigSendingTime()\n    FIX::OrigSendingTime(bool)\n    FIX::OrigSendingTime(FIX::UTCTIMESTAMP const &)\n    FIX::OrigSendingTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedLegIssuerLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  FIX::EncodedLegIssuerLen *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedLegIssuerLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncodedLegIssuerLen__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncodedLegIssuerLen'.\n  Possible C/C++ prototypes are:\n    FIX::EncodedLegIssuerLen()\n    FIX::EncodedLegIssuerLen(FIX::LENGTH const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::OrderID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OrderID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OrderID'.\n  Possible C/C++ prototypes are:\n    FIX::OrderID()\n    FIX::OrderID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SecurityType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecurityType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecurityType'.\n  Possible C/C++ prototypes are:\n    FIX::SecurityType()\n    FIX::SecurityType(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RoundingDirection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::RoundingDirection *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RoundingDirection(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RoundingDirection__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RoundingDirection'.\n  Possible C/C++ prototypes are:\n    FIX::RoundingDirection()\n    FIX::RoundingDirection(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FillExecID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::FillExecID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FillExecID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_FillExecID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_FillExecID'.\n  Possible C/C++ prototypes are:\n    FIX::FillExecID()\n    FIX::FillExecID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoEvents__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoEvents *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoEvents(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoEvents__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoEvents'.\n  Possible C/C++ prototypes are:\n    FIX::NoEvents()\n    FIX::NoEvents(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RoundLot__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::RoundLot *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RoundLot(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RoundLot__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RoundLot'.\n  Possible C/C++ prototypes are:\n    FIX::RoundLot()\n    FIX::RoundLot(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntrySize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::MDEntrySize *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntrySize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MDEntrySize__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MDEntrySize'.\n  Possible C/C++ prototypes are:\n    FIX::MDEntrySize()\n    FIX::MDEntrySize(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedIssuerLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  FIX::EncodedIssuerLen *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedIssuerLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncodedIssuerLen__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncodedIssuerLen'.\n  Possible C/C++ prototypes are:\n    FIX::EncodedIssuerLen()\n    FIX::EncodedIssuerLen(FIX::LENGTH const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativePriceUnitOfMeasureQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::DerivativePriceUnitOfMeasureQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativePriceUnitOfMeasureQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativePriceUnitOfMeasureQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativePriceUnitOfMeasureQty'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativePriceUnitOfMeasureQty()\n    FIX::DerivativePriceUnitOfMeasureQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeUnit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::TimeUnit *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeUnit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TimeUnit__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TimeUnit'.\n  Possible C/C++ prototypes are:\n    FIX::TimeUnit()\n    FIX::TimeUnit(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoOrders__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TotNoOrders *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoOrders(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TotNoOrders__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TotNoOrders'.\n  Possible C/C++ prototypes are:\n    FIX::TotNoOrders()\n    FIX::TotNoOrders(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_PartyAltID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PartyAltID *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_PartyAltID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PartyAltID *)new FIX::PartyAltID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PartyAltID, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_PartyAltID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_PartyAltID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PartyAltID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PartyAltID'.\n  Possible C/C++ prototypes are:\n    FIX::PartyAltID()\n    FIX::PartyAltID(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *PartyAltID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PartyAltID, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSwapType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::LegSwapType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSwapType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegSwapType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegSwapType'.\n  Possible C/C++ prototypes are:\n    FIX::LegSwapType()\n    FIX::LegSwapType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOITransType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::IOITransType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOITransType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_IOITransType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_IOITransType'.\n  Possible C/C++ prototypes are:\n    FIX::IOITransType()\n    FIX::IOITransType(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawDataLength__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  FIX::RawDataLength *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawDataLength(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RawDataLength__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RawDataLength'.\n  Possible C/C++ prototypes are:\n    FIX::RawDataLength()\n    FIX::RawDataLength(FIX::LENGTH const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingSecurityType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingSecurityType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingSecurityType'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingSecurityType()\n    FIX::UnderlyingSecurityType(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityAltID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingLegSecurityAltID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityAltID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingLegSecurityAltID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingLegSecurityAltID'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingLegSecurityAltID()\n    FIX::UnderlyingLegSecurityAltID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityReportID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::SecurityReportID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityReportID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecurityReportID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecurityReportID'.\n  Possible C/C++ prototypes are:\n    FIX::SecurityReportID()\n    FIX::SecurityReportID(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNumReports__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TotNumReports *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNumReports(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TotNumReports__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TotNumReports'.\n  Possible C/C++ prototypes are:\n    FIX::TotNumReports()\n    FIX::TotNumReports(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalNumPosReports__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TotalNumPosReports *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalNumPosReports(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TotalNumPosReports__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TotalNumPosReports'.\n  Possible C/C++ prototypes are:\n    FIX::TotalNumPosReports()\n    FIX::TotalNumPosReports(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SecurityReqID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecurityReqID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecurityReqID'.\n  Possible C/C++ prototypes are:\n    FIX::SecurityReqID()\n    FIX::SecurityReqID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosReqResult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::PosReqResult *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosReqResult(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PosReqResult__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PosReqResult'.\n  Possible C/C++ prototypes are:\n    FIX::PosReqResult()\n    FIX::PosReqResult(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegOfferForwardPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  FIX::LegOfferForwardPoints *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegOfferForwardPoints(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegOfferForwardPoints__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegOfferForwardPoints'.\n  Possible C/C++ prototypes are:\n    FIX::LegOfferForwardPoints()\n    FIX::LegOfferForwardPoints(FIX::PRICEOFFSET const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllowableOneSidednessCurr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  FIX::AllowableOneSidednessCurr *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllowableOneSidednessCurr(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllowableOneSidednessCurr__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllowableOneSidednessCurr'.\n  Possible C/C++ prototypes are:\n    FIX::AllowableOneSidednessCurr()\n    FIX::AllowableOneSidednessCurr(FIX::CURRENCY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AffectedOrderID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::AffectedOrderID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AffectedOrderID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AffectedOrderID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AffectedOrderID'.\n  Possible C/C++ prototypes are:\n    FIX::AffectedOrderID()\n    FIX::AffectedOrderID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCountryOfIssue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::COUNTRY *arg1 = 0 ;
  FIX::UnderlyingCountryOfIssue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCountryOfIssue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingCountryOfIssue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingCountryOfIssue'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingCountryOfIssue()\n    FIX::UnderlyingCountryOfIssue(FIX::COUNTRY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingRepurchaseRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::UnderlyingRepurchaseRate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingRepurchaseRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingRepurchaseRate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingRepurchaseRate'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingRepurchaseRate()\n    FIX::UnderlyingRepurchaseRate(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastMsgSeqNumProcessed__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SEQNUM *arg1 = 0 ;
  FIX::LastMsgSeqNumProcessed *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastMsgSeqNumProcessed(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LastMsgSeqNumProcessed__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LastMsgSeqNumProcessed'.\n  Possible C/C++ prototypes are:\n    FIX::LastMsgSeqNumProcessed()\n    FIX::LastMsgSeqNumProcessed(FIX::SEQNUM const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCFICode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingCFICode *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCFICode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingCFICode__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingCFICode'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingCFICode()\n    FIX::UnderlyingCFICode(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeOptAttribute__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::DerivativeOptAttribute *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeOptAttribute(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeOptAttribute__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeOptAttribute'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeOptAttribute()\n    FIX::DerivativeOptAttribute(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegSecurityID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::PegSecurityID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegSecurityID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PegSecurityID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PegSecurityID'.\n  Possible C/C++ prototypes are:\n    FIX::PegSecurityID()\n    FIX::PegSecurityID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HostCrossID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::HostCrossID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HostCrossID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_HostCrossID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_HostCrossID'.\n  Possible C/C++ prototypes are:\n    FIX::HostCrossID()\n    FIX::HostCrossID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecInstValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::ExecInstValue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecInstValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ExecInstValue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ExecInstValue'.\n  Possible C/C++ prototypes are:\n    FIX::ExecInstValue()\n    FIX::ExecInstValue(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeOptPayAmount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::DerivativeOptPayAmount *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeOptPayAmount(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeOptPayAmount__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeOptPayAmount'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeOptPayAmount()\n    FIX::DerivativeOptPayAmount(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCouponRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::UnderlyingCouponRate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCouponRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingCouponRate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingCouponRate'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingCouponRate()\n    FIX::UnderlyingCouponRate(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::SettlInstMode *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstMode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlInstMode__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlInstMode'.\n  Possible C/C++ prototypes are:\n    FIX::SettlInstMode()\n    FIX::SettlInstMode(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityAltIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SecurityAltIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityAltIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecurityAltIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecurityAltIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::SecurityAltIDSource()\n    FIX::SecurityAltIDSource(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PreviouslyReported__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::PreviouslyReported *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PreviouslyReported(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PreviouslyReported__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PreviouslyReported'.\n  Possible C/C++ prototypes are:\n    FIX::PreviouslyReported()\n    FIX::PreviouslyReported(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_ContextPartyIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContextPartyIDSource *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_ContextPartyIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContextPartyIDSource *)new FIX::ContextPartyIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContextPartyIDSource, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContextPartyIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::ContextPartyIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_ContextPartyIDSource",&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_ContextPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ContextPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContextPartyIDSource *)new FIX::ContextPartyIDSource((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContextPartyIDSource, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContextPartyIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_ContextPartyIDSource__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ContextPartyIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ContextPartyIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::ContextPartyIDSource()\n    FIX::ContextPartyIDSource(FIX::CHAR const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *ContextPartyIDSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ContextPartyIDSource, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RptSys__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::RptSys *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RptSys(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RptSys__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RptSys'.\n  Possible C/C++ prototypes are:\n    FIX::RptSys()\n    FIX::RptSys(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNested2PartySubIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoNested2PartySubIDs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNested2PartySubIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoNested2PartySubIDs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoNested2PartySubIDs'.\n  Possible C/C++ prototypes are:\n    FIX::NoNested2PartySubIDs()\n    FIX::NoNested2PartySubIDs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefAllocID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::RefAllocID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefAllocID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RefAllocID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RefAllocID'.\n  Possible C/C++ prototypes are:\n    FIX::RefAllocID()\n    FIX::RefAllocID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefOfferSize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::DefOfferSize *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefOfferSize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DefOfferSize__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DefOfferSize'.\n  Possible C/C++ prototypes are:\n    FIX::DefOfferSize()\n    FIX::DefOfferSize(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ProductComplex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ProductComplex *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ProductComplex(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ProductComplex__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ProductComplex'.\n  Possible C/C++ prototypes are:\n    FIX::ProductComplex()\n    FIX::ProductComplex(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CustOrderHandlingInst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MULTIPLESTRINGVALUE *arg1 = 0 ;
  FIX::CustOrderHandlingInst *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CustOrderHandlingInst(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CustOrderHandlingInst__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CustOrderHandlingInst'.\n  Possible C/C++ prototypes are:\n    FIX::CustOrderHandlingInst()\n    FIX::CustOrderHandlingInst(FIX::MULTIPLESTRINGVALUE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDPriceLevel__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::MDPriceLevel *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDPriceLevel(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MDPriceLevel__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MDPriceLevel'.\n  Possible C/C++ prototypes are:\n    FIX::MDPriceLevel()\n    FIX::MDPriceLevel(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegOptionRatio__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::LegOptionRatio *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegOptionRatio(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegOptionRatio__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegOptionRatio'.\n  Possible C/C++ prototypes are:\n    FIX::LegOptionRatio()\n    FIX::LegOptionRatio(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SecurityStatus *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecurityStatus__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecurityStatus'.\n  Possible C/C++ prototypes are:\n    FIX::SecurityStatus()\n    FIX::SecurityStatus(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LegRefID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegRefID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegRefID'.\n  Possible C/C++ prototypes are:\n    FIX::LegRefID()\n    FIX::LegRefID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DividendYield__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::DividendYield *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DividendYield(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DividendYield__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DividendYield'.\n  Possible C/C++ prototypes are:\n    FIX::DividendYield()\n    FIX::DividendYield(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrumentPartySubIDType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::DerivativeInstrumentPartySubIDType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrumentPartySubIDType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeInstrumentPartySubIDType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeInstrumentPartySubIDType'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeInstrumentPartySubIDType()\n    FIX::DerivativeInstrumentPartySubIDType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EndStrikePxRange__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::EndStrikePxRange *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EndStrikePxRange(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EndStrikePxRange__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EndStrikePxRange'.\n  Possible C/C++ prototypes are:\n    FIX::EndStrikePxRange()\n    FIX::EndStrikePxRange(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DisplayQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::DisplayQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DisplayQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DisplayQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DisplayQty'.\n  Possible C/C++ prototypes are:\n    FIX::DisplayQty()\n    FIX::DisplayQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSecuritySubType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LegSecuritySubType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSecuritySubType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegSecuritySubType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegSecuritySubType'.\n  Possible C/C++ prototypes are:\n    FIX::LegSecuritySubType()\n    FIX::LegSecuritySubType(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ProcessCode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::ProcessCode *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ProcessCode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ProcessCode__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ProcessCode'.\n  Possible C/C++ prototypes are:\n    FIX::ProcessCode()\n    FIX::ProcessCode(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecInst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MULTIPLECHARVALUE *arg1 = 0 ;
  FIX::ExecInst *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecInst(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ExecInst__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ExecInst'.\n  Possible C/C++ prototypes are:\n    FIX::ExecInst()\n    FIX::ExecInst(FIX::MULTIPLECHARVALUE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesEndTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  FIX::TradSesEndTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesEndTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  FIX::TradSesEndTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesEndTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  FIX::TradSesEndTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesEndTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_new_TradSesEndTime__SWIG_3(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradSesEndTime'.\n  Possible C/C++ prototypes are:\n    FIX::TradSesEndTime()\n    FIX::TradSesEndTime(bool)\n    FIX::TradSesEndTime(FIX::UTCTIMESTAMP const &)\n    FIX::TradSesEndTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  FIX::OrigTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  FIX::OrigTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  FIX::OrigTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_new_OrigTime__SWIG_3(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OrigTime'.\n  Possible C/C++ prototypes are:\n    FIX::OrigTime()\n    FIX::OrigTime(bool)\n    FIX::OrigTime(FIX::UTCTIMESTAMP const &)\n    FIX::OrigTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecValuationPoint__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  FIX::ExecValuationPoint *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecValuationPoint__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  FIX::ExecValuationPoint *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecValuationPoint__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  FIX::ExecValuationPoint *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecValuationPoint(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_new_ExecValuationPoint__SWIG_3(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ExecValuationPoint'.\n  Possible C/C++ prototypes are:\n    FIX::ExecValuationPoint()\n    FIX::ExecValuationPoint(bool)\n    FIX::ExecValuationPoint(FIX::UTCTIMESTAMP const &)\n    FIX::ExecValuationPoint(FIX::UTCTIMESTAMP const &,bool)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::ExecType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ExecType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ExecType'.\n  Possible C/C++ prototypes are:\n    FIX::ExecType()\n    FIX::ExecType(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_NoRelatedContextPartySubIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoRelatedContextPartySubIDs *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_NoRelatedContextPartySubIDs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRelatedContextPartySubIDs *)new FIX::NoRelatedContextPartySubIDs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRelatedContextPartySubIDs, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRelatedContextPartySubIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRelatedContextPartySubIDs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoRelatedContextPartySubIDs",&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_NoRelatedContextPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoRelatedContextPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRelatedContextPartySubIDs *)new FIX::NoRelatedContextPartySubIDs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRelatedContextPartySubIDs, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRelatedContextPartySubIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_NoRelatedContextPartySubIDs__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoRelatedContextPartySubIDs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoRelatedContextPartySubIDs'.\n  Possible C/C++ prototypes are:\n    FIX::NoRelatedContextPartySubIDs()\n    FIX::NoRelatedContextPartySubIDs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *NoRelatedContextPartySubIDs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoRelatedContextPartySubIDs, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested4PartyRole__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::Nested4PartyRole *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested4PartyRole(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Nested4PartyRole__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Nested4PartyRole'.\n  Possible C/C++ prototypes are:\n    FIX::Nested4PartyRole()\n    FIX::Nested4PartyRole(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MultilegModel__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::MultilegModel *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MultilegModel(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MultilegModel__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MultilegModel'.\n  Possible C/C++ prototypes are:\n    FIX::MultilegModel()\n    FIX::MultilegModel(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityGroup__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SecurityGroup *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityGroup(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecurityGroup__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecurityGroup'.\n  Possible C/C++ prototypes are:\n    FIX::SecurityGroup()\n    FIX::SecurityGroup(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EventType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::EventType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EventType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EventType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EventType'.\n  Possible C/C++ prototypes are:\n    FIX::EventType()\n    FIX::EventType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeAllocIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TradeAllocIndicator *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeAllocIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradeAllocIndicator__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradeAllocIndicator'.\n  Possible C/C++ prototypes are:\n    FIX::TradeAllocIndicator()\n    FIX::TradeAllocIndicator(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YieldCalcDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::YieldCalcDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YieldCalcDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_YieldCalcDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_YieldCalcDate'.\n  Possible C/C++ prototypes are:\n    FIX::YieldCalcDate()\n    FIX::YieldCalcDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ValueOfFutures__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::ValueOfFutures *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ValueOfFutures(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ValueOfFutures__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ValueOfFutures'.\n  Possible C/C++ prototypes are:\n    FIX::ValueOfFutures()\n    FIX::ValueOfFutures(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSide__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::LegSide *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSide(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegSide__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegSide'.\n  Possible C/C++ prototypes are:\n    FIX::LegSide()\n    FIX::LegSide(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UserStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::UserStatus *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UserStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UserStatus__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UserStatus'.\n  Possible C/C++ prototypes are:\n    FIX::UserStatus()\n    FIX::UserStatus(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideValue1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::SideValue1 *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideValue1(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SideValue1__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SideValue1'.\n  Possible C/C++ prototypes are:\n    FIX::SideValue1()\n    FIX::SideValue1(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CxlQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::CxlQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CxlQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CxlQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CxlQty'.\n  Possible C/C++ prototypes are:\n    FIX::CxlQty()\n    FIX::CxlQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityResponseID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SecurityResponseID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityResponseID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecurityResponseID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecurityResponseID'.\n  Possible C/C++ prototypes are:\n    FIX::SecurityResponseID()\n    FIX::SecurityResponseID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrRegistry__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::InstrRegistry *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrRegistry(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_InstrRegistry__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_InstrRegistry'.\n  Possible C/C++ prototypes are:\n    FIX::InstrRegistry()\n    FIX::InstrRegistry(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StreamAsgnRptID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::StreamAsgnRptID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StreamAsgnRptID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StreamAsgnRptID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StreamAsgnRptID'.\n  Possible C/C++ prototypes are:\n    FIX::StreamAsgnRptID()\n    FIX::StreamAsgnRptID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderDelayUnit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::OrderDelayUnit *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderDelayUnit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OrderDelayUnit__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OrderDelayUnit'.\n  Possible C/C++ prototypes are:\n    FIX::OrderDelayUnit()\n    FIX::OrderDelayUnit(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCurrencyRatio__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::LegCurrencyRatio *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCurrencyRatio(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegCurrencyRatio__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegCurrencyRatio'.\n  Possible C/C++ prototypes are:\n    FIX::LegCurrencyRatio()\n    FIX::LegCurrencyRatio(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EndTickPriceRange__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::EndTickPriceRange *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EndTickPriceRange(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EndTickPriceRange__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EndTickPriceRange'.\n  Possible C/C++ prototypes are:\n    FIX::EndTickPriceRange()\n    FIX::EndTickPriceRange(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::CollReqID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CollReqID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CollReqID'.\n  Possible C/C++ prototypes are:\n    FIX::CollReqID()\n    FIX::CollReqID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegPool__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LegPool *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegPool(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegPool__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegPool'.\n  Possible C/C++ prototypes are:\n    FIX::LegPool()\n    FIX::LegPool(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ShortQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::ShortQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ShortQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ShortQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ShortQty'.\n  Possible C/C++ prototypes are:\n    FIX::ShortQty()\n    FIX::ShortQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideValue2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::SideValue2 *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideValue2(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SideValue2__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SideValue2'.\n  Possible C/C++ prototypes are:\n    FIX::SideValue2()\n    FIX::SideValue2(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradedFlatSwitch__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::TradedFlatSwitch *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradedFlatSwitch(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradedFlatSwitch__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradedFlatSwitch'.\n  Possible C/C++ prototypes are:\n    FIX::TradedFlatSwitch()\n    FIX::TradedFlatSwitch(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassStatusReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::MassStatusReqID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassStatusReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MassStatusReqID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MassStatusReqID'.\n  Possible C/C++ prototypes are:\n    FIX::MassStatusReqID()\n    FIX::MassStatusReqID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventEndDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  FIX::ComplexEventEndDate *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventEndDate__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  FIX::ComplexEventEndDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventEndDate__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  FIX::ComplexEventEndDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventEndDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_new_ComplexEventEndDate__SWIG_3(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ComplexEventEndDate'.\n  Possible C/C++ prototypes are:\n    FIX::ComplexEventEndDate()\n    FIX::ComplexEventEndDate(bool)\n    FIX::ComplexEventEndDate(FIX::UTCTIMESTAMP const &)\n    FIX::ComplexEventEndDate(FIX::UTCTIMESTAMP const &,bool)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarketID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EXCHANGE *arg1 = 0 ;
  FIX::MarketID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarketID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MarketID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MarketID'.\n  Possible C/C++ prototypes are:\n    FIX::MarketID()\n    FIX::MarketID(FIX::EXCHANGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigTradeDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::OrigTradeDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigTradeDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OrigTradeDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OrigTradeDate'.\n  Possible C/C++ prototypes are:\n    FIX::OrigTradeDate()\n    FIX::OrigTradeDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PreTradeAnonymity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::PreTradeAnonymity *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PreTradeAnonymity(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PreTradeAnonymity__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PreTradeAnonymity'.\n  Possible C/C++ prototypes are:\n    FIX::PreTradeAnonymity()\n    FIX::PreTradeAnonymity(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdRptStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TrdRptStatus *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdRptStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TrdRptStatus__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TrdRptStatus'.\n  Possible C/C++ prototypes are:\n    FIX::TrdRptStatus()\n    FIX::TrdRptStatus(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DistribPercentage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::DistribPercentage *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DistribPercentage(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DistribPercentage__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DistribPercentage'.\n  Possible C/C++ prototypes are:\n    FIX::DistribPercentage()\n    FIX::DistribPercentage(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::QuoteStatus *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_QuoteStatus__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_QuoteStatus'.\n  Possible C/C++ prototypes are:\n    FIX::QuoteStatus()\n    FIX::QuoteStatus(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClearingAccount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ClearingAccount *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClearingAccount(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ClearingAccount__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ClearingAccount'.\n  Possible C/C++ prototypes are:\n    FIX::ClearingAccount()\n    FIX::ClearingAccount(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdMatchID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::TrdMatchID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdMatchID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TrdMatchID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TrdMatchID'.\n  Possible C/C++ prototypes are:\n    FIX::TrdMatchID()\n    FIX::TrdMatchID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderInputDevice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::OrderInputDevice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderInputDevice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OrderInputDevice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OrderInputDevice'.\n  Possible C/C++ prototypes are:\n    FIX::OrderInputDevice()\n    FIX::OrderInputDevice(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SolicitedFlag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::SolicitedFlag *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SolicitedFlag(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SolicitedFlag__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SolicitedFlag'.\n  Possible C/C++ prototypes are:\n    FIX::SolicitedFlag()\n    FIX::SolicitedFlag(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TransactTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  FIX::TransactTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TransactTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  FIX::TransactTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TransactTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  FIX::TransactTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TransactTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_new_TransactTime__SWIG_3(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TransactTime'.\n  Possible C/C++ prototypes are:\n    FIX::TransactTime()\n    FIX::TransactTime(bool)\n    FIX::TransactTime(FIX::UTCTIMESTAMP const &)\n    FIX::TransactTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RiskLimitType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskLimitType *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RiskLimitType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskLimitType *)new FIX::RiskLimitType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskLimitType, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RiskLimitType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RiskLimitType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskLimitType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskLimitType'.\n  Possible C/C++ prototypes are:\n    FIX::RiskLimitType()\n    FIX::RiskLimitType(FIX::INT const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RiskLimitType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RiskLimitType, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingFlowScheduleType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::UnderlyingFlowScheduleType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingFlowScheduleType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingFlowScheduleType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingFlowScheduleType'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingFlowScheduleType()\n    FIX::UnderlyingFlowScheduleType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingStipValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingStipValue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingStipValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingStipValue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingStipValue'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingStipValue()\n    FIX::UnderlyingStipValue(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NextExpectedMsgSeqNum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SEQNUM *arg1 = 0 ;
  FIX::NextExpectedMsgSeqNum *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NextExpectedMsgSeqNum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NextExpectedMsgSeqNum__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NextExpectedMsgSeqNum'.\n  Possible C/C++ prototypes are:\n    FIX::NextExpectedMsgSeqNum()\n    FIX::NextExpectedMsgSeqNum(FIX::SEQNUM const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BenchmarkCurveCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  FIX::BenchmarkCurveCurrency *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BenchmarkCurveCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_BenchmarkCurveCurrency__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BenchmarkCurveCurrency'.\n  Possible C/C++ prototypes are:\n    FIX::BenchmarkCurveCurrency()\n    FIX::BenchmarkCurveCurrency(FIX::CURRENCY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CFICode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::CFICode *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CFICode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CFICode__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CFICode'.\n  Possible C/C++ prototypes are:\n    FIX::CFICode()\n    FIX::CFICode(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Factor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::Factor *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Factor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Factor__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Factor'.\n  Possible C/C++ prototypes are:\n    FIX::Factor()\n    FIX::Factor(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastShares__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::LastShares *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastShares(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LastShares__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LastShares'.\n  Possible C/C++ prototypes are:\n    FIX::LastShares()\n    FIX::LastShares(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RequestedPartyRole__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RequestedPartyRole *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RequestedPartyRole")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RequestedPartyRole *)new FIX::RequestedPartyRole();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RequestedPartyRole, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RequestedPartyRole(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RequestedPartyRole__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RequestedPartyRole__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RequestedPartyRole'.\n  Possible C/C++ prototypes are:\n    FIX::RequestedPartyRole()\n    FIX::RequestedPartyRole(FIX::INT const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RequestedPartyRole_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RequestedPartyRole, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EventTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  FIX::EventTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EventTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  FIX::EventTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EventTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  FIX::EventTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EventTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_new_EventTime__SWIG_3(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EventTime'.\n  Possible C/C++ prototypes are:\n    FIX::EventTime()\n    FIX::EventTime(bool)\n    FIX::EventTime(FIX::UTCTIMESTAMP const &)\n    FIX::EventTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RootPartySubIDType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::RootPartySubIDType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RootPartySubIDType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RootPartySubIDType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RootPartySubIDType'.\n  Possible C/C++ prototypes are:\n    FIX::RootPartySubIDType()\n    FIX::RootPartySubIDType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ShortSaleReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ShortSaleReason *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ShortSaleReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ShortSaleReason__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ShortSaleReason'.\n  Possible C/C++ prototypes are:\n    FIX::ShortSaleReason()\n    FIX::ShortSaleReason(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XmlData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  FIX::XmlData *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XmlData(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_XmlData__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_XmlData'.\n  Possible C/C++ prototypes are:\n    FIX::XmlData()\n    FIX::XmlData(FIX::DATA const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelationshipRiskSeniority__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelationshipRiskSeniority *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelationshipRiskSeniority")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskSeniority *)new FIX::RelationshipRiskSeniority();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskSeniority, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RelationshipRiskSeniority(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelationshipRiskSeniority__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelationshipRiskSeniority__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelationshipRiskSeniority'.\n  Possible C/C++ prototypes are:\n    FIX::RelationshipRiskSeniority()\n    FIX::RelationshipRiskSeniority(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelationshipRiskSeniority_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelationshipRiskSeniority, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTargetPartyIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoTargetPartyIDs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTargetPartyIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoTargetPartyIDs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoTargetPartyIDs'.\n  Possible C/C++ prototypes are:\n    FIX::NoTargetPartyIDs()\n    FIX::NoTargetPartyIDs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRootPartyIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRootPartyIDs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRootPartyIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoRootPartyIDs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoRootPartyIDs'.\n  Possible C/C++ prototypes are:\n    FIX::NoRootPartyIDs()\n    FIX::NoRootPartyIDs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EventDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::EventDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EventDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EventDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EventDate'.\n  Possible C/C++ prototypes are:\n    FIX::EventDate()\n    FIX::EventDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegRoundDirection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::PegRoundDirection *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegRoundDirection(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PegRoundDirection__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PegRoundDirection'.\n  Possible C/C++ prototypes are:\n    FIX::PegRoundDirection()\n    FIX::PegRoundDirection(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSettlDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::LegSettlDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSettlDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegSettlDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegSettlDate'.\n  Possible C/C++ prototypes are:\n    FIX::LegSettlDate()\n    FIX::LegSettlDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ModelType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ModelType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ModelType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ModelType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ModelType'.\n  Possible C/C++ prototypes are:\n    FIX::ModelType()\n    FIX::ModelType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefaultVerIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::DefaultVerIndicator *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefaultVerIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DefaultVerIndicator__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DefaultVerIndicator'.\n  Possible C/C++ prototypes are:\n    FIX::DefaultVerIndicator()\n    FIX::DefaultVerIndicator(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FuturesValuationMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::FuturesValuationMethod *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FuturesValuationMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_FuturesValuationMethod__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_FuturesValuationMethod'.\n  Possible C/C++ prototypes are:\n    FIX::FuturesValuationMethod()\n    FIX::FuturesValuationMethod(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::SettlMethod *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlMethod__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlMethod'.\n  Possible C/C++ prototypes are:\n    FIX::SettlMethod()\n    FIX::SettlMethod(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingFXRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::UnderlyingFXRate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingFXRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingFXRate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingFXRate'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingFXRate()\n    FIX::UnderlyingFXRate(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfirmStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ConfirmStatus *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfirmStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ConfirmStatus__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ConfirmStatus'.\n  Possible C/C++ prototypes are:\n    FIX::ConfirmStatus()\n    FIX::ConfirmStatus(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocateReqd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::LocateReqd *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocateReqd(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LocateReqd__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LocateReqd'.\n  Possible C/C++ prototypes are:\n    FIX::LocateReqd()\n    FIX::LocateReqd(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosMaintRptID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::PosMaintRptID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosMaintRptID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PosMaintRptID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PosMaintRptID'.\n  Possible C/C++ prototypes are:\n    FIX::PosMaintRptID()\n    FIX::PosMaintRptID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Adjustment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::Adjustment *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Adjustment(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Adjustment__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Adjustment'.\n  Possible C/C++ prototypes are:\n    FIX::Adjustment()\n    FIX::Adjustment(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StreamAsgnType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::StreamAsgnType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StreamAsgnType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StreamAsgnType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StreamAsgnType'.\n  Possible C/C++ prototypes are:\n    FIX::StreamAsgnType()\n    FIX::StreamAsgnType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastRptRequested__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::LastRptRequested *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastRptRequested(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LastRptRequested__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LastRptRequested'.\n  Possible C/C++ prototypes are:\n    FIX::LastRptRequested()\n    FIX::LastRptRequested(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocaleOfIssue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LocaleOfIssue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocaleOfIssue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LocaleOfIssue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LocaleOfIssue'.\n  Possible C/C++ prototypes are:\n    FIX::LocaleOfIssue()\n    FIX::LocaleOfIssue(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SenderSubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SenderSubID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SenderSubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SenderSubID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SenderSubID'.\n  Possible C/C++ prototypes are:\n    FIX::SenderSubID()\n    FIX::SenderSubID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HighPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::HighPx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HighPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_HighPx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_HighPx'.\n  Possible C/C++ prototypes are:\n    FIX::HighPx()\n    FIX::HighPx(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocSettlCurrAmt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::AllocSettlCurrAmt *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocSettlCurrAmt(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllocSettlCurrAmt__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllocSettlCurrAmt'.\n  Possible C/C++ prototypes are:\n    FIX::AllocSettlCurrAmt()\n    FIX::AllocSettlCurrAmt(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventPriceBoundaryPrecision__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::ComplexEventPriceBoundaryPrecision *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventPriceBoundaryPrecision(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ComplexEventPriceBoundaryPrecision__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ComplexEventPriceBoundaryPrecision'.\n  Possible C/C++ prototypes are:\n    FIX::ComplexEventPriceBoundaryPrecision()\n    FIX::ComplexEventPriceBoundaryPrecision(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrumentPartyRole__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::InstrumentPartyRole *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrumentPartyRole(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_InstrumentPartyRole__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_InstrumentPartyRole'.\n  Possible C/C++ prototypes are:\n    FIX::InstrumentPartyRole()\n    FIX::InstrumentPartyRole(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YieldRedemptionPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::YieldRedemptionPrice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YieldRedemptionPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_YieldRedemptionPrice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_YieldRedemptionPrice'.\n  Possible C/C++ prototypes are:\n    FIX::YieldRedemptionPrice()\n    FIX::YieldRedemptionPrice(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CumQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::CumQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CumQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CumQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CumQty'.\n  Possible C/C++ prototypes are:\n    FIX::CumQty()\n    FIX::CumQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigClOrdID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::OrigClOrdID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigClOrdID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OrigClOrdID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OrigClOrdID'.\n  Possible C/C++ prototypes are:\n    FIX::OrigClOrdID()\n    FIX::OrigClOrdID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlSessID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SettlSessID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlSessID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlSessID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlSessID'.\n  Possible C/C++ prototypes are:\n    FIX::SettlSessID()\n    FIX::SettlSessID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ParentMktSegmID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ParentMktSegmID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ParentMktSegmID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ParentMktSegmID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ParentMktSegmID'.\n  Possible C/C++ prototypes are:\n    FIX::ParentMktSegmID()\n    FIX::ParentMktSegmID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeReportType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TradeReportType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeReportType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradeReportType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradeReportType'.\n  Possible C/C++ prototypes are:\n    FIX::TradeReportType()\n    FIX::TradeReportType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AvgPrxPrecision__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::AvgPrxPrecision *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AvgPrxPrecision(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AvgPrxPrecision__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AvgPrxPrecision'.\n  Possible C/C++ prototypes are:\n    FIX::AvgPrxPrecision()\n    FIX::AvgPrxPrecision(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoLegs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoLegs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoLegs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoLegs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoLegs'.\n  Possible C/C++ prototypes are:\n    FIX::NoLegs()\n    FIX::NoLegs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSymbol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingSymbol *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSymbol(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingSymbol__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingSymbol'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingSymbol()\n    FIX::UnderlyingSymbol(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExerciseStyle__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ExerciseStyle *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExerciseStyle(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ExerciseStyle__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ExerciseStyle'.\n  Possible C/C++ prototypes are:\n    FIX::ExerciseStyle()\n    FIX::ExerciseStyle(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HaltReasonChar__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::HaltReasonChar *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HaltReasonChar(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_HaltReasonChar__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_HaltReasonChar'.\n  Possible C/C++ prototypes are:\n    FIX::HaltReasonChar()\n    FIX::HaltReasonChar(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExDestination__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EXCHANGE *arg1 = 0 ;
  FIX::ExDestination *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExDestination(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ExDestination__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ExDestination'.\n  Possible C/C++ prototypes are:\n    FIX::ExDestination()\n    FIX::ExDestination(FIX::EXCHANGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_NoPartyRelationships__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoPartyRelationships *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_NoPartyRelationships")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoPartyRelationships *)new FIX::NoPartyRelationships();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoPartyRelationships, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoPartyRelationships__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoPartyRelationships *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoPartyRelationships",&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_NoPartyRelationships" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoPartyRelationships" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoPartyRelationships *)new FIX::NoPartyRelationships((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoPartyRelationships, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoPartyRelationships(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_NoPartyRelationships__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoPartyRelationships__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoPartyRelationships'.\n  Possible C/C++ prototypes are:\n    FIX::NoPartyRelationships()\n    FIX::NoPartyRelationships(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *NoPartyRelationships_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoPartyRelationships, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrmtAssignmentMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::DerivativeInstrmtAssignmentMethod *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrmtAssignmentMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeInstrmtAssignmentMethod__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeInstrmtAssignmentMethod'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeInstrmtAssignmentMethod()\n    FIX::DerivativeInstrmtAssignmentMethod(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingIDSource()\n    FIX::UnderlyingIDSource(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AdvId__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::AdvId *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AdvId(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AdvId__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AdvId'.\n  Possible C/C++ prototypes are:\n    FIX::AdvId()\n    FIX::AdvId(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TransBkdTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  FIX::TransBkdTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TransBkdTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  FIX::TransBkdTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TransBkdTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  FIX::TransBkdTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TransBkdTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_new_TransBkdTime__SWIG_3(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TransBkdTime'.\n  Possible C/C++ prototypes are:\n    FIX::TransBkdTime()\n    FIX::TransBkdTime(bool)\n    FIX::TransBkdTime(FIX::UTCTIMESTAMP const &)\n    FIX::TransBkdTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegLastPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::LegLastPx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegLastPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegLastPx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegLastPx'.\n  Possible C/C++ prototypes are:\n    FIX::LegLastPx()\n    FIX::LegLastPx(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_NoRiskWarningLevels__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoRiskWarningLevels *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_NoRiskWarningLevels")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRiskWarningLevels *)new FIX::NoRiskWarningLevels();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRiskWarningLevels, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRiskWarningLevels__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRiskWarningLevels *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoRiskWarningLevels",&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_NoRiskWarningLevels" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoRiskWarningLevels" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRiskWarningLevels *)new FIX::NoRiskWarningLevels((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRiskWarningLevels, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRiskWarningLevels(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_NoRiskWarningLevels__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoRiskWarningLevels__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoRiskWarningLevels'.\n  Possible C/C++ prototypes are:\n    FIX::NoRiskWarningLevels()\n    FIX::NoRiskWarningLevels(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *NoRiskWarningLevels_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoRiskWarningLevels, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocReportType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::AllocReportType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocReportType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllocReportType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllocReportType'.\n  Possible C/C++ prototypes are:\n    FIX::AllocReportType()\n    FIX::AllocReportType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistDtls__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::RegistDtls *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistDtls(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RegistDtls__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RegistDtls'.\n  Possible C/C++ prototypes are:\n    FIX::RegistDtls()\n    FIX::RegistDtls(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::AllocType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllocType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllocType'.\n  Possible C/C++ prototypes are:\n    FIX::AllocType()\n    FIX::AllocType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteRequestRejectReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::QuoteRequestRejectReason *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteRequestRejectReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_QuoteRequestRejectReason__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_QuoteRequestRejectReason'.\n  Possible C/C++ prototypes are:\n    FIX::QuoteRequestRejectReason()\n    FIX::QuoteRequestRejectReason(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingUnitOfMeasure__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingUnitOfMeasure *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingUnitOfMeasure(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingUnitOfMeasure__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingUnitOfMeasure'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingUnitOfMeasure()\n    FIX::UnderlyingUnitOfMeasure(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IndividualAllocID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::IndividualAllocID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IndividualAllocID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_IndividualAllocID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_IndividualAllocID'.\n  Possible C/C++ prototypes are:\n    FIX::IndividualAllocID()\n    FIX::IndividualAllocID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegOfferPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::LegOfferPx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegOfferPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegOfferPx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegOfferPx'.\n  Possible C/C++ prototypes are:\n    FIX::LegOfferPx()\n    FIX::LegOfferPx(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LiquidityIndType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::LiquidityIndType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LiquidityIndType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LiquidityIndType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LiquidityIndType'.\n  Possible C/C++ prototypes are:\n    FIX::LiquidityIndType()\n    FIX::LiquidityIndType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HopSendingTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  FIX::HopSendingTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HopSendingTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  FIX::HopSendingTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HopSendingTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  FIX::HopSendingTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HopSendingTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_new_HopSendingTime__SWIG_3(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_HopSendingTime'.\n  Possible C/C++ prototypes are:\n    FIX::HopSendingTime()\n    FIX::HopSendingTime(bool)\n    FIX::HopSendingTime(FIX::UTCTIMESTAMP const &)\n    FIX::HopSendingTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelationshipRiskLimitAmount__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelationshipRiskLimitAmount *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelationshipRiskLimitAmount")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskLimitAmount *)new FIX::RelationshipRiskLimitAmount();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskLimitAmount, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelationshipRiskLimitAmount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::RelationshipRiskLimitAmount *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_RelationshipRiskLimitAmount",&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_RelationshipRiskLimitAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RelationshipRiskLimitAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskLimitAmount *)new FIX::RelationshipRiskLimitAmount((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskLimitAmount, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelationshipRiskLimitAmount(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelationshipRiskLimitAmount__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelationshipRiskLimitAmount__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelationshipRiskLimitAmount'.\n  Possible C/C++ prototypes are:\n    FIX::RelationshipRiskLimitAmount()\n    FIX::RelationshipRiskLimitAmount(FIX::AMT const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelationshipRiskLimitAmount_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelationshipRiskLimitAmount, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplResendFlag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::ApplResendFlag *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplResendFlag(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ApplResendFlag__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ApplResendFlag'.\n  Possible C/C++ prototypes are:\n    FIX::ApplResendFlag()\n    FIX::ApplResendFlag(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeCapPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::DerivativeCapPrice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeCapPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeCapPrice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeCapPrice'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeCapPrice()\n    FIX::DerivativeCapPrice(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RiskSecurityID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskSecurityID *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RiskSecurityID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskSecurityID *)new FIX::RiskSecurityID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskSecurityID, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RiskSecurityID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RiskSecurityID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskSecurityID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskSecurityID'.\n  Possible C/C++ prototypes are:\n    FIX::RiskSecurityID()\n    FIX::RiskSecurityID(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RiskSecurityID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RiskSecurityID, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexOptPayoutAmount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::ComplexOptPayoutAmount *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexOptPayoutAmount(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ComplexOptPayoutAmount__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ComplexOptPayoutAmount'.\n  Possible C/C++ prototypes are:\n    FIX::ComplexOptPayoutAmount()\n    FIX::ComplexOptPayoutAmount(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LanguageCode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LANGUAGE *arg1 = 0 ;
  FIX::LanguageCode *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LanguageCode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LanguageCode__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LanguageCode'.\n  Possible C/C++ prototypes are:\n    FIX::LanguageCode()\n    FIX::LanguageCode(FIX::LANGUAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlObligRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SettlObligRefID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlObligRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlObligRefID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlObligRefID'.\n  Possible C/C++ prototypes are:\n    FIX::SettlObligRefID()\n    FIX::SettlObligRefID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigTradeID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::OrigTradeID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigTradeID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OrigTradeID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OrigTradeID'.\n  Possible C/C++ prototypes are:\n    FIX::OrigTradeID()\n    FIX::OrigTradeID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCollectAmount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::UnderlyingCollectAmount *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCollectAmount(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingCollectAmount__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingCollectAmount'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingCollectAmount()\n    FIX::UnderlyingCollectAmount(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StatusValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::StatusValue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StatusValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StatusValue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StatusValue'.\n  Possible C/C++ prototypes are:\n    FIX::StatusValue()\n    FIX::StatusValue(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OfferSpotRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::OfferSpotRate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OfferSpotRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OfferSpotRate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OfferSpotRate'.\n  Possible C/C++ prototypes are:\n    FIX::OfferSpotRate()\n    FIX::OfferSpotRate(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::PosType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PosType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PosType'.\n  Possible C/C++ prototypes are:\n    FIX::PosType()\n    FIX::PosType(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingRedemptionDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::UnderlyingRedemptionDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingRedemptionDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingRedemptionDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingRedemptionDate'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingRedemptionDate()\n    FIX::UnderlyingRedemptionDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlDepositoryCode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SettlDepositoryCode *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlDepositoryCode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlDepositoryCode__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlDepositoryCode'.\n  Possible C/C++ prototypes are:\n    FIX::SettlDepositoryCode()\n    FIX::SettlDepositoryCode(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StreamAsgnAckType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::StreamAsgnAckType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StreamAsgnAckType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StreamAsgnAckType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StreamAsgnAckType'.\n  Possible C/C++ prototypes are:\n    FIX::StreamAsgnAckType()\n    FIX::StreamAsgnAckType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FloorPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::FloorPrice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FloorPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_FloorPrice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_FloorPrice'.\n  Possible C/C++ prototypes are:\n    FIX::FloorPrice()\n    FIX::FloorPrice(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RiskMaturityTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskMaturityTime *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RiskMaturityTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskMaturityTime *)new FIX::RiskMaturityTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskMaturityTime, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RiskMaturityTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TZTIMEONLY *arg1 = 0 ;
  FIX::RiskMaturityTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_RiskMaturityTime",&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_RiskMaturityTime" "', argument " "1"" of type '" "FIX::TZTIMEONLY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RiskMaturityTime" "', argument " "1"" of type '" "FIX::TZTIMEONLY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::TZTIMEONLY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskMaturityTime *)new FIX::RiskMaturityTime((FIX::TZTIMEONLY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskMaturityTime, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RiskMaturityTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RiskMaturityTime__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskMaturityTime__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskMaturityTime'.\n  Possible C/C++ prototypes are:\n    FIX::RiskMaturityTime()\n    FIX::RiskMaturityTime(FIX::TZTIMEONLY const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RiskMaturityTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RiskMaturityTime, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingPriceUnitOfMeasureQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::UnderlyingPriceUnitOfMeasureQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingPriceUnitOfMeasureQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingPriceUnitOfMeasureQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingPriceUnitOfMeasureQty'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingPriceUnitOfMeasureQty()\n    FIX::UnderlyingPriceUnitOfMeasureQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FeeMultiplier__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::FeeMultiplier *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FeeMultiplier(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_FeeMultiplier__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_FeeMultiplier'.\n  Possible C/C++ prototypes are:\n    FIX::FeeMultiplier()\n    FIX::FeeMultiplier(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingMaturityTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TZTIMEONLY *arg1 = 0 ;
  FIX::UnderlyingMaturityTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingMaturityTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingMaturityTime__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingMaturityTime'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingMaturityTime()\n    FIX::UnderlyingMaturityTime(FIX::TZTIMEONLY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ApplID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ApplID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ApplID'.\n  Possible C/C++ prototypes are:\n    FIX::ApplID()\n    FIX::ApplID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegGrossTradeAmt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::LegGrossTradeAmt *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegGrossTradeAmt(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegGrossTradeAmt__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegGrossTradeAmt'.\n  Possible C/C++ prototypes are:\n    FIX::LegGrossTradeAmt()\n    FIX::LegGrossTradeAmt(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCDATEONLY *arg1 = 0 ;
  FIX::MDEntryDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MDEntryDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MDEntryDate'.\n  Possible C/C++ prototypes are:\n    FIX::MDEntryDate()\n    FIX::MDEntryDate(FIX::UTCDATEONLY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegBenchmarkCurveCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  FIX::LegBenchmarkCurveCurrency *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegBenchmarkCurveCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegBenchmarkCurveCurrency__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegBenchmarkCurveCurrency'.\n  Possible C/C++ prototypes are:\n    FIX::LegBenchmarkCurveCurrency()\n    FIX::LegBenchmarkCurveCurrency(FIX::CURRENCY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RiskInstrumentOperator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskInstrumentOperator *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RiskInstrumentOperator")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskInstrumentOperator *)new FIX::RiskInstrumentOperator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskInstrumentOperator, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RiskInstrumentOperator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RiskInstrumentOperator__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskInstrumentOperator__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskInstrumentOperator'.\n  Possible C/C++ prototypes are:\n    FIX::RiskInstrumentOperator()\n    FIX::RiskInstrumentOperator(FIX::INT const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RiskInstrumentOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RiskInstrumentOperator, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OptPayoutAmount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::OptPayoutAmount *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OptPayoutAmount(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OptPayoutAmount__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OptPayoutAmount'.\n  Possible C/C++ prototypes are:\n    FIX::OptPayoutAmount()\n    FIX::OptPayoutAmount(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MiscFeeBasis__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::MiscFeeBasis *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MiscFeeBasis(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MiscFeeBasis__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MiscFeeBasis'.\n  Possible C/C++ prototypes are:\n    FIX::MiscFeeBasis()\n    FIX::MiscFeeBasis(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ValidUntilTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  FIX::ValidUntilTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ValidUntilTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  FIX::ValidUntilTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ValidUntilTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  FIX::ValidUntilTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ValidUntilTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_new_ValidUntilTime__SWIG_3(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ValidUntilTime'.\n  Possible C/C++ prototypes are:\n    FIX::ValidUntilTime()\n    FIX::ValidUntilTime(bool)\n    FIX::ValidUntilTime(FIX::UTCTIMESTAMP const &)\n    FIX::ValidUntilTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrdType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::OrdType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrdType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OrdType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OrdType'.\n  Possible C/C++ prototypes are:\n    FIX::OrdType()\n    FIX::OrdType(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AdvRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::AdvRefID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AdvRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AdvRefID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AdvRefID'.\n  Possible C/C++ prototypes are:\n    FIX::AdvRefID()\n    FIX::AdvRefID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HopCompID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::HopCompID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HopCompID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_HopCompID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_HopCompID'.\n  Possible C/C++ prototypes are:\n    FIX::HopCompID()\n    FIX::HopCompID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosMaintRptRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::PosMaintRptRefID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosMaintRptRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PosMaintRptRefID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PosMaintRptRefID'.\n  Possible C/C++ prototypes are:\n    FIX::PosMaintRptRefID()\n    FIX::PosMaintRptRefID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegStipulationValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LegStipulationValue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegStipulationValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegStipulationValue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegStipulationValue'.\n  Possible C/C++ prototypes are:\n    FIX::LegStipulationValue()\n    FIX::LegStipulationValue(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MatchType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::MatchType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MatchType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MatchType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MatchType'.\n  Possible C/C++ prototypes are:\n    FIX::MatchType()\n    FIX::MatchType(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OptPayoutType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::OptPayoutType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OptPayoutType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OptPayoutType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OptPayoutType'.\n  Possible C/C++ prototypes are:\n    FIX::OptPayoutType()\n    FIX::OptPayoutType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingPriceUnitOfMeasure__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingPriceUnitOfMeasure *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingPriceUnitOfMeasure(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingPriceUnitOfMeasure__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingPriceUnitOfMeasure'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingPriceUnitOfMeasure()\n    FIX::UnderlyingPriceUnitOfMeasure(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarketUpdateAction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::MarketUpdateAction *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarketUpdateAction(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MarketUpdateAction__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MarketUpdateAction'.\n  Possible C/C++ prototypes are:\n    FIX::MarketUpdateAction()\n    FIX::MarketUpdateAction(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollAsgnRejectReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::CollAsgnRejectReason *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollAsgnRejectReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CollAsgnRejectReason__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CollAsgnRejectReason'.\n  Possible C/C++ prototypes are:\n    FIX::CollAsgnRejectReason()\n    FIX::CollAsgnRejectReason(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PeggedRefPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::PeggedRefPrice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PeggedRefPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PeggedRefPrice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PeggedRefPrice'.\n  Possible C/C++ prototypes are:\n    FIX::PeggedRefPrice()\n    FIX::PeggedRefPrice(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IndividualAllocType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::IndividualAllocType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IndividualAllocType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_IndividualAllocType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_IndividualAllocType'.\n  Possible C/C++ prototypes are:\n    FIX::IndividualAllocType()\n    FIX::IndividualAllocType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EndCash__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::EndCash *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EndCash(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EndCash__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EndCash'.\n  Possible C/C++ prototypes are:\n    FIX::EndCash()\n    FIX::EndCash(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EventText__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::EventText *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EventText(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EventText__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EventText'.\n  Possible C/C++ prototypes are:\n    FIX::EventText()\n    FIX::EventText(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::ExDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ExDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ExDate'.\n  Possible C/C++ prototypes are:\n    FIX::ExDate()\n    FIX::ExDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NestedPartyIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::NestedPartyIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NestedPartyIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NestedPartyIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NestedPartyIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::NestedPartyIDSource()\n    FIX::NestedPartyIDSource(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GTBookingInst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::GTBookingInst *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GTBookingInst(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_GTBookingInst__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_GTBookingInst'.\n  Possible C/C++ prototypes are:\n    FIX::GTBookingInst()\n    FIX::GTBookingInst(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeValuationMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DerivativeValuationMethod *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeValuationMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeValuationMethod__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeValuationMethod'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeValuationMethod()\n    FIX::DerivativeValuationMethod(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NumberOfOrders__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::NumberOfOrders *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NumberOfOrders(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NumberOfOrders__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NumberOfOrders'.\n  Possible C/C++ prototypes are:\n    FIX::NumberOfOrders()\n    FIX::NumberOfOrders(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdRepPartyRole__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TrdRepPartyRole *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdRepPartyRole(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TrdRepPartyRole__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TrdRepPartyRole'.\n  Possible C/C++ prototypes are:\n    FIX::TrdRepPartyRole()\n    FIX::TrdRepPartyRole(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::TriggerPrice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TriggerPrice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TriggerPrice'.\n  Possible C/C++ prototypes are:\n    FIX::TriggerPrice()\n    FIX::TriggerPrice(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDReportID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::MDReportID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDReportID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MDReportID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MDReportID'.\n  Possible C/C++ prototypes are:\n    FIX::MDReportID()\n    FIX::MDReportID(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryAllocID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SecondaryAllocID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryAllocID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecondaryAllocID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecondaryAllocID'.\n  Possible C/C++ prototypes are:\n    FIX::SecondaryAllocID()\n    FIX::SecondaryAllocID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LeavesQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::LeavesQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LeavesQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LeavesQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LeavesQty'.\n  Possible C/C++ prototypes are:\n    FIX::LeavesQty()\n    FIX::LeavesQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CardStartDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::CardStartDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CardStartDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CardStartDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CardStartDate'.\n  Possible C/C++ prototypes are:\n    FIX::CardStartDate()\n    FIX::CardStartDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCoveredOrUncovered__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::LegCoveredOrUncovered *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCoveredOrUncovered(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegCoveredOrUncovered__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegCoveredOrUncovered'.\n  Possible C/C++ prototypes are:\n    FIX::LegCoveredOrUncovered()\n    FIX::LegCoveredOrUncovered(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PutOrCall__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::PutOrCall *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PutOrCall(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PutOrCall__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PutOrCall'.\n  Possible C/C++ prototypes are:\n    FIX::PutOrCall()\n    FIX::PutOrCall(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MatchAlgorithm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::MatchAlgorithm *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MatchAlgorithm(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MatchAlgorithm__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MatchAlgorithm'.\n  Possible C/C++ prototypes are:\n    FIX::MatchAlgorithm()\n    FIX::MatchAlgorithm(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CalculatedCcyLastQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::CalculatedCcyLastQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CalculatedCcyLastQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CalculatedCcyLastQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CalculatedCcyLastQty'.\n  Possible C/C++ prototypes are:\n    FIX::CalculatedCcyLastQty()\n    FIX::CalculatedCcyLastQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FundRenewWaiv__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::FundRenewWaiv *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FundRenewWaiv(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_FundRenewWaiv__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_FundRenewWaiv'.\n  Possible C/C++ prototypes are:\n    FIX::FundRenewWaiv()\n    FIX::FundRenewWaiv(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecuritySettlAgentName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SecuritySettlAgentName *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecuritySettlAgentName(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecuritySettlAgentName__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecuritySettlAgentName'.\n  Possible C/C++ prototypes are:\n    FIX::SecuritySettlAgentName()\n    FIX::SecuritySettlAgentName(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidDescriptor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::BidDescriptor *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidDescriptor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_BidDescriptor__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BidDescriptor'.\n  Possible C/C++ prototypes are:\n    FIX::BidDescriptor()\n    FIX::BidDescriptor(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelationshipRiskSecurityAltIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelationshipRiskSecurityAltIDSource *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelationshipRiskSecurityAltIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskSecurityAltIDSource *)new FIX::RelationshipRiskSecurityAltIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskSecurityAltIDSource, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RelationshipRiskSecurityAltIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelationshipRiskSecurityAltIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelationshipRiskSecurityAltIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelationshipRiskSecurityAltIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::RelationshipRiskSecurityAltIDSource()\n    FIX::RelationshipRiskSecurityAltIDSource(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelationshipRiskSecurityAltIDSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelationshipRiskSecurityAltIDSource, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDStreamID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::MDStreamID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDStreamID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MDStreamID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MDStreamID'.\n  Possible C/C++ prototypes are:\n    FIX::MDStreamID()\n    FIX::MDStreamID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoAsgnReqs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoAsgnReqs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoAsgnReqs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoAsgnReqs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoAsgnReqs'.\n  Possible C/C++ prototypes are:\n    FIX::NoAsgnReqs()\n    FIX::NoAsgnReqs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NotionalPercentageOutstanding__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::NotionalPercentageOutstanding *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NotionalPercentageOutstanding(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NotionalPercentageOutstanding__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NotionalPercentageOutstanding'.\n  Possible C/C++ prototypes are:\n    FIX::NotionalPercentageOutstanding()\n    FIX::NotionalPercentageOutstanding(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSettlInst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoSettlInst *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSettlInst(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoSettlInst__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoSettlInst'.\n  Possible C/C++ prototypes are:\n    FIX::NoSettlInst()\n    FIX::NoSettlInst(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstMsgID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SettlInstMsgID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstMsgID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlInstMsgID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlInstMsgID'.\n  Possible C/C++ prototypes are:\n    FIX::SettlInstMsgID()\n    FIX::SettlInstMsgID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ForexReq__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::ForexReq *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ForexReq(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ForexReq__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ForexReq'.\n  Possible C/C++ prototypes are:\n    FIX::ForexReq()\n    FIX::ForexReq(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::TradSesReqID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradSesReqID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradSesReqID'.\n  Possible C/C++ prototypes are:\n    FIX::TradSesReqID()\n    FIX::TradSesReqID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegStrikePrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::UnderlyingLegStrikePrice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegStrikePrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingLegStrikePrice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingLegStrikePrice'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingLegStrikePrice()\n    FIX::UnderlyingLegStrikePrice(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TickRuleType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TickRuleType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TickRuleType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TickRuleType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TickRuleType'.\n  Possible C/C++ prototypes are:\n    FIX::TickRuleType()\n    FIX::TickRuleType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrmtAssignmentMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::InstrmtAssignmentMethod *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrmtAssignmentMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_InstrmtAssignmentMethod__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_InstrmtAssignmentMethod'.\n  Possible C/C++ prototypes are:\n    FIX::InstrmtAssignmentMethod()\n    FIX::InstrmtAssignmentMethod(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionOffsetType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::DiscretionOffsetType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionOffsetType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DiscretionOffsetType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DiscretionOffsetType'.\n  Possible C/C++ prototypes are:\n    FIX::DiscretionOffsetType()\n    FIX::DiscretionOffsetType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfirmTransType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ConfirmTransType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfirmTransType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ConfirmTransType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ConfirmTransType'.\n  Possible C/C++ prototypes are:\n    FIX::ConfirmTransType()\n    FIX::ConfirmTransType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalTakedown__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::TotalTakedown *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalTakedown(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TotalTakedown__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TotalTakedown'.\n  Possible C/C++ prototypes are:\n    FIX::TotalTakedown()\n    FIX::TotalTakedown(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ResponseDestination__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ResponseDestination *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ResponseDestination(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ResponseDestination__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ResponseDestination'.\n  Possible C/C++ prototypes are:\n    FIX::ResponseDestination()\n    FIX::ResponseDestination(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDSecSizeType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::MDSecSizeType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDSecSizeType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MDSecSizeType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MDSecSizeType'.\n  Possible C/C++ prototypes are:\n    FIX::MDSecSizeType()\n    FIX::MDSecSizeType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrumentPartySubIDType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::InstrumentPartySubIDType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrumentPartySubIDType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_InstrumentPartySubIDType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_InstrumentPartySubIDType'.\n  Possible C/C++ prototypes are:\n    FIX::InstrumentPartySubIDType()\n    FIX::InstrumentPartySubIDType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegTimeUnit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LegTimeUnit *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegTimeUnit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegTimeUnit__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegTimeUnit'.\n  Possible C/C++ prototypes are:\n    FIX::LegTimeUnit()\n    FIX::LegTimeUnit(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TransferReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::TransferReason *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TransferReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TransferReason__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TransferReason'.\n  Possible C/C++ prototypes are:\n    FIX::TransferReason()\n    FIX::TransferReason(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplQueueMax__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ApplQueueMax *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplQueueMax(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ApplQueueMax__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ApplQueueMax'.\n  Possible C/C++ prototypes are:\n    FIX::ApplQueueMax()\n    FIX::ApplQueueMax(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionOffsetValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::DiscretionOffsetValue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionOffsetValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DiscretionOffsetValue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DiscretionOffsetValue'.\n  Possible C/C++ prototypes are:\n    FIX::DiscretionOffsetValue()\n    FIX::DiscretionOffsetValue(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BookingRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::BookingRefID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BookingRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_BookingRefID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BookingRefID'.\n  Possible C/C++ prototypes are:\n    FIX::BookingRefID()\n    FIX::BookingRefID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegBidPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::LegBidPx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegBidPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegBidPx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegBidPx'.\n  Possible C/C++ prototypes are:\n    FIX::LegBidPx()\n    FIX::LegBidPx(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_ContextPartyRole__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContextPartyRole *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_ContextPartyRole")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContextPartyRole *)new FIX::ContextPartyRole();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContextPartyRole, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_ContextPartyRole(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_ContextPartyRole__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ContextPartyRole__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ContextPartyRole'.\n  Possible C/C++ prototypes are:\n    FIX::ContextPartyRole()\n    FIX::ContextPartyRole(FIX::INT const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *ContextPartyRole_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ContextPartyRole, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesEvent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TradSesEvent *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesEvent(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradSesEvent__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradSesEvent'.\n  Possible C/C++ prototypes are:\n    FIX::TradSesEvent()\n    FIX::TradSesEvent(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeProduct__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::DerivativeProduct *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeProduct(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeProduct__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeProduct'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeProduct()\n    FIX::DerivativeProduct(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RootPartyRole__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::RootPartyRole *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RootPartyRole(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RootPartyRole__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RootPartyRole'.\n  Possible C/C++ prototypes are:\n    FIX::RootPartyRole()\n    FIX::RootPartyRole(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DlvyInstType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::DlvyInstType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DlvyInstType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DlvyInstType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DlvyInstType'.\n  Possible C/C++ prototypes are:\n    FIX::DlvyInstType()\n    FIX::DlvyInstType(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoLinesOfText__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoLinesOfText *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoLinesOfText(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoLinesOfText__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoLinesOfText'.\n  Possible C/C++ prototypes are:\n    FIX::NoLinesOfText()\n    FIX::NoLinesOfText(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::PosReqID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PosReqID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PosReqID'.\n  Possible C/C++ prototypes are:\n    FIX::PosReqID()\n    FIX::PosReqID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSecurityAltIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LegSecurityAltIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSecurityAltIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegSecurityAltIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegSecurityAltIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::LegSecurityAltIDSource()\n    FIX::LegSecurityAltIDSource(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedSubject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  FIX::EncodedSubject *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedSubject(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncodedSubject__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncodedSubject'.\n  Possible C/C++ prototypes are:\n    FIX::EncodedSubject()\n    FIX::EncodedSubject(FIX::DATA const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContraBroker__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ContraBroker *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContraBroker(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ContraBroker__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ContraBroker'.\n  Possible C/C++ prototypes are:\n    FIX::ContraBroker()\n    FIX::ContraBroker(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeCondition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MULTIPLESTRINGVALUE *arg1 = 0 ;
  FIX::TradeCondition *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeCondition(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradeCondition__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradeCondition'.\n  Possible C/C++ prototypes are:\n    FIX::TradeCondition()\n    FIX::TradeCondition(FIX::MULTIPLESTRINGVALUE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PartyID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::PartyID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PartyID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PartyID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PartyID'.\n  Possible C/C++ prototypes are:\n    FIX::PartyID()\n    FIX::PartyID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::MDEntryID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MDEntryID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MDEntryID'.\n  Possible C/C++ prototypes are:\n    FIX::MDEntryID()\n    FIX::MDEntryID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityExchange__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingLegSecurityExchange *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityExchange(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingLegSecurityExchange__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingLegSecurityExchange'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingLegSecurityExchange()\n    FIX::UnderlyingLegSecurityExchange(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriceLimitType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::PriceLimitType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriceLimitType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PriceLimitType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PriceLimitType'.\n  Possible C/C++ prototypes are:\n    FIX::PriceLimitType()\n    FIX::PriceLimitType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerSecurityIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::TriggerSecurityIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerSecurityIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TriggerSecurityIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TriggerSecurityIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::TriggerSecurityIDSource()\n    FIX::TriggerSecurityIDSource(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoUndlyInstrumentPartySubIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoUndlyInstrumentPartySubIDs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoUndlyInstrumentPartySubIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoUndlyInstrumentPartySubIDs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoUndlyInstrumentPartySubIDs'.\n  Possible C/C++ prototypes are:\n    FIX::NoUndlyInstrumentPartySubIDs()\n    FIX::NoUndlyInstrumentPartySubIDs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClientBidID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ClientBidID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClientBidID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ClientBidID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ClientBidID'.\n  Possible C/C++ prototypes are:\n    FIX::ClientBidID()\n    FIX::ClientBidID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetChgPrevDay__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  FIX::NetChgPrevDay *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetChgPrevDay(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NetChgPrevDay__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NetChgPrevDay'.\n  Possible C/C++ prototypes are:\n    FIX::NetChgPrevDay()\n    FIX::NetChgPrevDay(FIX::PRICEOFFSET const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefaultApplVerID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DefaultApplVerID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefaultApplVerID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DefaultApplVerID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DefaultApplVerID'.\n  Possible C/C++ prototypes are:\n    FIX::DefaultApplVerID()\n    FIX::DefaultApplVerID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOIID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::IOIID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOIID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_IOIID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_IOIID'.\n  Possible C/C++ prototypes are:\n    FIX::IOIID()\n    FIX::IOIID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpreadToBenchmark__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  FIX::SpreadToBenchmark *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpreadToBenchmark(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SpreadToBenchmark__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SpreadToBenchmark'.\n  Possible C/C++ prototypes are:\n    FIX::SpreadToBenchmark()\n    FIX::SpreadToBenchmark(FIX::PRICEOFFSET const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CommType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::CommType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CommType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CommType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CommType'.\n  Possible C/C++ prototypes are:\n    FIX::CommType()\n    FIX::CommType(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistRejReasonCode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::RegistRejReasonCode *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistRejReasonCode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RegistRejReasonCode__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RegistRejReasonCode'.\n  Possible C/C++ prototypes are:\n    FIX::RegistRejReasonCode()\n    FIX::RegistRejReasonCode(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelationshipRiskEncodedSecurityDesc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelationshipRiskEncodedSecurityDesc *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelationshipRiskEncodedSecurityDesc")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskEncodedSecurityDesc *)new FIX::RelationshipRiskEncodedSecurityDesc();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskEncodedSecurityDesc, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelationshipRiskEncodedSecurityDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  FIX::RelationshipRiskEncodedSecurityDesc *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_RelationshipRiskEncodedSecurityDesc",&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_RelationshipRiskEncodedSecurityDesc" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RelationshipRiskEncodedSecurityDesc" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskEncodedSecurityDesc *)new FIX::RelationshipRiskEncodedSecurityDesc((FIX::DATA const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskEncodedSecurityDesc, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelationshipRiskEncodedSecurityDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelationshipRiskEncodedSecurityDesc__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelationshipRiskEncodedSecurityDesc__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelationshipRiskEncodedSecurityDesc'.\n  Possible C/C++ prototypes are:\n    FIX::RelationshipRiskEncodedSecurityDesc()\n    FIX::RelationshipRiskEncodedSecurityDesc(FIX::DATA const &)\n");
  return NULL;
}


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


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

SWIGINTERN PyObject *_wrap_new_RelationshipRiskRestructuringType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelationshipRiskRestructuringType *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelationshipRiskRestructuringType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskRestructuringType *)new FIX::RelationshipRiskRestructuringType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskRestructuringType, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RelationshipRiskRestructuringType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelationshipRiskRestructuringType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelationshipRiskRestructuringType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelationshipRiskRestructuringType'.\n  Possible C/C++ prototypes are:\n    FIX::RelationshipRiskRestructuringType()\n    FIX::RelationshipRiskRestructuringType(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelationshipRiskRestructuringType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelationshipRiskRestructuringType, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideTimeInForce__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  FIX::SideTimeInForce *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideTimeInForce__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  FIX::SideTimeInForce *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideTimeInForce__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  FIX::SideTimeInForce *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideTimeInForce(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_new_SideTimeInForce__SWIG_3(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SideTimeInForce'.\n  Possible C/C++ prototypes are:\n    FIX::SideTimeInForce()\n    FIX::SideTimeInForce(bool)\n    FIX::SideTimeInForce(FIX::UTCTIMESTAMP const &)\n    FIX::SideTimeInForce(FIX::UTCTIMESTAMP const &,bool)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdRegTimestamp__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  FIX::TrdRegTimestamp *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdRegTimestamp__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  FIX::TrdRegTimestamp *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdRegTimestamp__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  FIX::TrdRegTimestamp *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdRegTimestamp(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_new_TrdRegTimestamp__SWIG_3(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TrdRegTimestamp'.\n  Possible C/C++ prototypes are:\n    FIX::TrdRegTimestamp()\n    FIX::TrdRegTimestamp(bool)\n    FIX::TrdRegTimestamp(FIX::UTCTIMESTAMP const &)\n    FIX::TrdRegTimestamp(FIX::UTCTIMESTAMP const &,bool)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FinancialStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MULTIPLECHARVALUE *arg1 = 0 ;
  FIX::FinancialStatus *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FinancialStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_FinancialStatus__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_FinancialStatus'.\n  Possible C/C++ prototypes are:\n    FIX::FinancialStatus()\n    FIX::FinancialStatus(FIX::MULTIPLECHARVALUE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTrades__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoTrades *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTrades(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoTrades__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoTrades'.\n  Possible C/C++ prototypes are:\n    FIX::NoTrades()\n    FIX::NoTrades(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastFragment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::LastFragment *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastFragment(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LastFragment__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LastFragment'.\n  Possible C/C++ prototypes are:\n    FIX::LastFragment()\n    FIX::LastFragment(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PartySubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::PartySubID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PartySubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PartySubID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PartySubID'.\n  Possible C/C++ prototypes are:\n    FIX::PartySubID()\n    FIX::PartySubID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::AllocQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllocQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllocQty'.\n  Possible C/C++ prototypes are:\n    FIX::AllocQty()\n    FIX::AllocQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NotifyBrokerOfCredit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::NotifyBrokerOfCredit *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NotifyBrokerOfCredit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NotifyBrokerOfCredit__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NotifyBrokerOfCredit'.\n  Possible C/C++ prototypes are:\n    FIX::NotifyBrokerOfCredit()\n    FIX::NotifyBrokerOfCredit(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideTrdRegTimestampType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::SideTrdRegTimestampType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideTrdRegTimestampType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SideTrdRegTimestampType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SideTrdRegTimestampType'.\n  Possible C/C++ prototypes are:\n    FIX::SideTrdRegTimestampType()\n    FIX::SideTrdRegTimestampType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AgreementDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::AgreementDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AgreementDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AgreementDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AgreementDate'.\n  Possible C/C++ prototypes are:\n    FIX::AgreementDate()\n    FIX::AgreementDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PartySubIDType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::PartySubIDType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PartySubIDType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PartySubIDType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PartySubIDType'.\n  Possible C/C++ prototypes are:\n    FIX::PartySubIDType()\n    FIX::PartySubIDType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalNetValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::TotalNetValue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalNetValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TotalNetValue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TotalNetValue'.\n  Possible C/C++ prototypes are:\n    FIX::TotalNetValue()\n    FIX::TotalNetValue(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocNoOrdersType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::AllocNoOrdersType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocNoOrdersType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllocNoOrdersType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllocNoOrdersType'.\n  Possible C/C++ prototypes are:\n    FIX::AllocNoOrdersType()\n    FIX::AllocNoOrdersType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocLinkID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::AllocLinkID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocLinkID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllocLinkID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllocLinkID'.\n  Possible C/C++ prototypes are:\n    FIX::AllocLinkID()\n    FIX::AllocLinkID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RoundingModulus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::RoundingModulus *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RoundingModulus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RoundingModulus__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RoundingModulus'.\n  Possible C/C++ prototypes are:\n    FIX::RoundingModulus()\n    FIX::RoundingModulus(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OnBehalfOfCompID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::OnBehalfOfCompID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OnBehalfOfCompID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OnBehalfOfCompID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OnBehalfOfCompID'.\n  Possible C/C++ prototypes are:\n    FIX::OnBehalfOfCompID()\n    FIX::OnBehalfOfCompID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingSecurityID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingSecurityID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingSecurityID'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingSecurityID()\n    FIX::UnderlyingSecurityID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlObligMsgID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SettlObligMsgID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlObligMsgID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlObligMsgID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlObligMsgID'.\n  Possible C/C++ prototypes are:\n    FIX::SettlObligMsgID()\n    FIX::SettlObligMsgID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PositionLimit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::PositionLimit *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PositionLimit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PositionLimit__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PositionLimit'.\n  Possible C/C++ prototypes are:\n    FIX::PositionLimit()\n    FIX::PositionLimit(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SharedCommission__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::SharedCommission *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SharedCommission(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SharedCommission__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SharedCommission'.\n  Possible C/C++ prototypes are:\n    FIX::SharedCommission()\n    FIX::SharedCommission(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllowableOneSidednessPct__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::AllowableOneSidednessPct *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllowableOneSidednessPct(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllowableOneSidednessPct__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllowableOneSidednessPct'.\n  Possible C/C++ prototypes are:\n    FIX::AllowableOneSidednessPct()\n    FIX::AllowableOneSidednessPct(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocText__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::AllocText *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocText(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllocText__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllocText'.\n  Possible C/C++ prototypes are:\n    FIX::AllocText()\n    FIX::AllocText(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EndSeqNo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SEQNUM *arg1 = 0 ;
  FIX::EndSeqNo *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EndSeqNo(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EndSeqNo__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EndSeqNo'.\n  Possible C/C++ prototypes are:\n    FIX::EndSeqNo()\n    FIX::EndSeqNo(FIX::SEQNUM const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoPartyIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoPartyIDs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoPartyIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoPartyIDs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoPartyIDs'.\n  Possible C/C++ prototypes are:\n    FIX::NoPartyIDs()\n    FIX::NoPartyIDs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoContraBrokers__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoContraBrokers *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoContraBrokers(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoContraBrokers__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoContraBrokers'.\n  Possible C/C++ prototypes are:\n    FIX::NoContraBrokers()\n    FIX::NoContraBrokers(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocLinkType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::AllocLinkType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocLinkType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllocLinkType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllocLinkType'.\n  Possible C/C++ prototypes are:\n    FIX::AllocLinkType()\n    FIX::AllocLinkType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingAllocationPercent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::UnderlyingAllocationPercent *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingAllocationPercent(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingAllocationPercent__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingAllocationPercent'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingAllocationPercent()\n    FIX::UnderlyingAllocationPercent(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocAccruedInterestAmt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::AllocAccruedInterestAmt *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocAccruedInterestAmt(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllocAccruedInterestAmt__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllocAccruedInterestAmt'.\n  Possible C/C++ prototypes are:\n    FIX::AllocAccruedInterestAmt()\n    FIX::AllocAccruedInterestAmt(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RiskSecuritySubType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskSecuritySubType *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RiskSecuritySubType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskSecuritySubType *)new FIX::RiskSecuritySubType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskSecuritySubType, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RiskSecuritySubType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RiskSecuritySubType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskSecuritySubType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskSecuritySubType'.\n  Possible C/C++ prototypes are:\n    FIX::RiskSecuritySubType()\n    FIX::RiskSecuritySubType(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RiskSecuritySubType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RiskSecuritySubType, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedSecurityListDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  FIX::EncodedSecurityListDesc *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedSecurityListDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncodedSecurityListDesc__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncodedSecurityListDesc'.\n  Possible C/C++ prototypes are:\n    FIX::EncodedSecurityListDesc()\n    FIX::EncodedSecurityListDesc(FIX::DATA const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncryptedPasswordLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  FIX::EncryptedPasswordLen *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncryptedPasswordLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncryptedPasswordLen__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncryptedPasswordLen'.\n  Possible C/C++ prototypes are:\n    FIX::EncryptedPasswordLen()\n    FIX::EncryptedPasswordLen(FIX::LENGTH const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegDividendYield__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::LegDividendYield *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegDividendYield(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegDividendYield__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegDividendYield'.\n  Possible C/C++ prototypes are:\n    FIX::LegDividendYield()\n    FIX::LegDividendYield(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefreshIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::RefreshIndicator *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefreshIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RefreshIndicator__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RefreshIndicator'.\n  Possible C/C++ prototypes are:\n    FIX::RefreshIndicator()\n    FIX::RefreshIndicator(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideSettlCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  FIX::SideSettlCurrency *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideSettlCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SideSettlCurrency__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SideSettlCurrency'.\n  Possible C/C++ prototypes are:\n    FIX::SideSettlCurrency()\n    FIX::SideSettlCurrency(FIX::CURRENCY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSettlementType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::UnderlyingSettlementType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSettlementType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingSettlementType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingSettlementType'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingSettlementType()\n    FIX::UnderlyingSettlementType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderCapacityQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::OrderCapacityQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderCapacityQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OrderCapacityQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OrderCapacityQty'.\n  Possible C/C++ prototypes are:\n    FIX::OrderCapacityQty()\n    FIX::OrderCapacityQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LongQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::LongQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LongQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LongQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LongQty'.\n  Possible C/C++ prototypes are:\n    FIX::LongQty()\n    FIX::LongQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_NoPartyAltIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoPartyAltIDs *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_NoPartyAltIDs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoPartyAltIDs *)new FIX::NoPartyAltIDs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoPartyAltIDs, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoPartyAltIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoPartyAltIDs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoPartyAltIDs",&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_NoPartyAltIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoPartyAltIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoPartyAltIDs *)new FIX::NoPartyAltIDs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoPartyAltIDs, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoPartyAltIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_NoPartyAltIDs__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoPartyAltIDs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoPartyAltIDs'.\n  Possible C/C++ prototypes are:\n    FIX::NoPartyAltIDs()\n    FIX::NoPartyAltIDs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *NoPartyAltIDs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoPartyAltIDs, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSettlMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::DerivativeSettlMethod *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSettlMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeSettlMethod__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeSettlMethod'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeSettlMethod()\n    FIX::DerivativeSettlMethod(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerTradingSessionID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::TriggerTradingSessionID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerTradingSessionID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TriggerTradingSessionID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TriggerTradingSessionID'.\n  Possible C/C++ prototypes are:\n    FIX::TriggerTradingSessionID()\n    FIX::TriggerTradingSessionID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DisplayMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::DisplayMethod *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DisplayMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DisplayMethod__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DisplayMethod'.\n  Possible C/C++ prototypes are:\n    FIX::DisplayMethod()\n    FIX::DisplayMethod(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RptSeq__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::RptSeq *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RptSeq(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RptSeq__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RptSeq'.\n  Possible C/C++ prototypes are:\n    FIX::RptSeq()\n    FIX::RptSeq(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryOriginator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::MDEntryOriginator *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryOriginator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MDEntryOriginator__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MDEntryOriginator'.\n  Possible C/C++ prototypes are:\n    FIX::MDEntryOriginator()\n    FIX::MDEntryOriginator(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegInstrRegistry__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LegInstrRegistry *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegInstrRegistry(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegInstrRegistry__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegInstrRegistry'.\n  Possible C/C++ prototypes are:\n    FIX::LegInstrRegistry()\n    FIX::LegInstrRegistry(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FillQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::FillQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FillQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_FillQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_FillQty'.\n  Possible C/C++ prototypes are:\n    FIX::FillQty()\n    FIX::FillQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegSecurityIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::PegSecurityIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegSecurityIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PegSecurityIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PegSecurityIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::PegSecurityIDSource()\n    FIX::PegSecurityIDSource(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TZTIMEONLY *arg1 = 0 ;
  FIX::MaturityTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MaturityTime__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MaturityTime'.\n  Possible C/C++ prototypes are:\n    FIX::MaturityTime()\n    FIX::MaturityTime(FIX::TZTIMEONLY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDFeedType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::MDFeedType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDFeedType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MDFeedType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MDFeedType'.\n  Possible C/C++ prototypes are:\n    FIX::MDFeedType()\n    FIX::MDFeedType(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::CollStatus *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CollStatus__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CollStatus'.\n  Possible C/C++ prototypes are:\n    FIX::CollStatus()\n    FIX::CollStatus(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSecuritySubType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingSecuritySubType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSecuritySubType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingSecuritySubType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingSecuritySubType'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingSecuritySubType()\n    FIX::UnderlyingSecuritySubType(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CstmApplVerID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::CstmApplVerID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CstmApplVerID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CstmApplVerID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CstmApplVerID'.\n  Possible C/C++ prototypes are:\n    FIX::CstmApplVerID()\n    FIX::CstmApplVerID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefaultApplExtID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::DefaultApplExtID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefaultApplExtID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DefaultApplExtID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DefaultApplExtID'.\n  Possible C/C++ prototypes are:\n    FIX::DefaultApplExtID()\n    FIX::DefaultApplExtID(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoDerivativeSecurityAltID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoDerivativeSecurityAltID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoDerivativeSecurityAltID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoDerivativeSecurityAltID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoDerivativeSecurityAltID'.\n  Possible C/C++ prototypes are:\n    FIX::NoDerivativeSecurityAltID()\n    FIX::NoDerivativeSecurityAltID(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideValueInd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::SideValueInd *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideValueInd(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SideValueInd__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SideValueInd'.\n  Possible C/C++ prototypes are:\n    FIX::SideValueInd()\n    FIX::SideValueInd(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedText__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  FIX::EncodedText *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedText(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncodedText__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncodedText'.\n  Possible C/C++ prototypes are:\n    FIX::EncodedText()\n    FIX::EncodedText(FIX::DATA const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Account__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::Account *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Account(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Account__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Account'.\n  Possible C/C++ prototypes are:\n    FIX::Account()\n    FIX::Account(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerNewPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::TriggerNewPrice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerNewPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TriggerNewPrice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TriggerNewPrice'.\n  Possible C/C++ prototypes are:\n    FIX::TriggerNewPrice()\n    FIX::TriggerNewPrice(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndlyInstrumentPartyRole__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::UndlyInstrumentPartyRole *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndlyInstrumentPartyRole(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UndlyInstrumentPartyRole__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UndlyInstrumentPartyRole'.\n  Possible C/C++ prototypes are:\n    FIX::UndlyInstrumentPartyRole()\n    FIX::UndlyInstrumentPartyRole(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MsgDirection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::MsgDirection *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MsgDirection(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MsgDirection__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MsgDirection'.\n  Possible C/C++ prototypes are:\n    FIX::MsgDirection()\n    FIX::MsgDirection(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegMaturityDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::LegMaturityDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegMaturityDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegMaturityDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegMaturityDate'.\n  Possible C/C++ prototypes are:\n    FIX::LegMaturityDate()\n    FIX::LegMaturityDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingContractMultiplierUnit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::UnderlyingContractMultiplierUnit *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingContractMultiplierUnit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingContractMultiplierUnit__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingContractMultiplierUnit'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingContractMultiplierUnit()\n    FIX::UnderlyingContractMultiplierUnit(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InputSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::InputSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InputSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_InputSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_InputSource'.\n  Possible C/C++ prototypes are:\n    FIX::InputSource()\n    FIX::InputSource(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDUpdateAction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::MDUpdateAction *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDUpdateAction(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MDUpdateAction__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MDUpdateAction'.\n  Possible C/C++ prototypes are:\n    FIX::MDUpdateAction()\n    FIX::MDUpdateAction(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MatchStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::MatchStatus *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MatchStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MatchStatus__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MatchStatus'.\n  Possible C/C++ prototypes are:\n    FIX::MatchStatus()\n    FIX::MatchStatus(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RateSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::RateSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RateSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RateSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RateSource'.\n  Possible C/C++ prototypes are:\n    FIX::RateSource()\n    FIX::RateSource(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocPositionEffect__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::AllocPositionEffect *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocPositionEffect(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllocPositionEffect__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllocPositionEffect'.\n  Possible C/C++ prototypes are:\n    FIX::AllocPositionEffect()\n    FIX::AllocPositionEffect(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PartyIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::PartyIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PartyIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PartyIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PartyIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::PartyIDSource()\n    FIX::PartyIDSource(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedUnderlyingIssuer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  FIX::EncodedUnderlyingIssuer *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedUnderlyingIssuer(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncodedUnderlyingIssuer__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncodedUnderlyingIssuer'.\n  Possible C/C++ prototypes are:\n    FIX::EncodedUnderlyingIssuer()\n    FIX::EncodedUnderlyingIssuer(FIX::DATA const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_NoRequestedPartyRoles__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoRequestedPartyRoles *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_NoRequestedPartyRoles")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRequestedPartyRoles *)new FIX::NoRequestedPartyRoles();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRequestedPartyRoles, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRequestedPartyRoles__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRequestedPartyRoles *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoRequestedPartyRoles",&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_NoRequestedPartyRoles" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoRequestedPartyRoles" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRequestedPartyRoles *)new FIX::NoRequestedPartyRoles((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRequestedPartyRoles, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRequestedPartyRoles(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_NoRequestedPartyRoles__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoRequestedPartyRoles__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoRequestedPartyRoles'.\n  Possible C/C++ prototypes are:\n    FIX::NoRequestedPartyRoles()\n    FIX::NoRequestedPartyRoles(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *NoRequestedPartyRoles_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoRequestedPartyRoles, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncryptedPassword__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  FIX::EncryptedPassword *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncryptedPassword(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncryptedPassword__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncryptedPassword'.\n  Possible C/C++ prototypes are:\n    FIX::EncryptedPassword()\n    FIX::EncryptedPassword(FIX::DATA const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerNewQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::TriggerNewQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerNewQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TriggerNewQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TriggerNewQty'.\n  Possible C/C++ prototypes are:\n    FIX::TriggerNewQty()\n    FIX::TriggerNewQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegLastForwardPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  FIX::LegLastForwardPoints *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegLastForwardPoints(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegLastForwardPoints__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegLastForwardPoints'.\n  Possible C/C++ prototypes are:\n    FIX::LegLastForwardPoints()\n    FIX::LegLastForwardPoints(FIX::PRICEOFFSET const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNumTradeReports__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TotNumTradeReports *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNumTradeReports(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TotNumTradeReports__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TotNumTradeReports'.\n  Possible C/C++ prototypes are:\n    FIX::TotNumTradeReports()\n    FIX::TotNumTradeReports(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefApplVerID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::RefApplVerID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefApplVerID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RefApplVerID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RefApplVerID'.\n  Possible C/C++ prototypes are:\n    FIX::RefApplVerID()\n    FIX::RefApplVerID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastSpotRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::LastSpotRate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastSpotRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LastSpotRate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LastSpotRate'.\n  Possible C/C++ prototypes are:\n    FIX::LastSpotRate()\n    FIX::LastSpotRate(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Price__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::Price *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Price(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Price__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Price'.\n  Possible C/C++ prototypes are:\n    FIX::Price()\n    FIX::Price(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingSecurityIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingSecurityIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingSecurityIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingSecurityIDSource()\n    FIX::UnderlyingSecurityIDSource(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoSecurityTypes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TotNoSecurityTypes *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoSecurityTypes(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TotNoSecurityTypes__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TotNoSecurityTypes'.\n  Possible C/C++ prototypes are:\n    FIX::TotNoSecurityTypes()\n    FIX::TotNoSecurityTypes(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelationshipRiskInstrumentMultiplier__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelationshipRiskInstrumentMultiplier *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelationshipRiskInstrumentMultiplier")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskInstrumentMultiplier *)new FIX::RelationshipRiskInstrumentMultiplier();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskInstrumentMultiplier, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelationshipRiskInstrumentMultiplier__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::RelationshipRiskInstrumentMultiplier *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_RelationshipRiskInstrumentMultiplier",&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_RelationshipRiskInstrumentMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RelationshipRiskInstrumentMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskInstrumentMultiplier *)new FIX::RelationshipRiskInstrumentMultiplier((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskInstrumentMultiplier, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelationshipRiskInstrumentMultiplier(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelationshipRiskInstrumentMultiplier__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelationshipRiskInstrumentMultiplier__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelationshipRiskInstrumentMultiplier'.\n  Possible C/C++ prototypes are:\n    FIX::RelationshipRiskInstrumentMultiplier()\n    FIX::RelationshipRiskInstrumentMultiplier(FIX::FLOAT const &)\n");
  return NULL;
}


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


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

SWIGINTERN PyObject *_wrap_new_NoRiskInstruments__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoRiskInstruments *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_NoRiskInstruments")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRiskInstruments *)new FIX::NoRiskInstruments();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRiskInstruments, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRiskInstruments__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRiskInstruments *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoRiskInstruments",&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_NoRiskInstruments" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoRiskInstruments" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRiskInstruments *)new FIX::NoRiskInstruments((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRiskInstruments, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRiskInstruments(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_NoRiskInstruments__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoRiskInstruments__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoRiskInstruments'.\n  Possible C/C++ prototypes are:\n    FIX::NoRiskInstruments()\n    FIX::NoRiskInstruments(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *NoRiskInstruments_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoRiskInstruments, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ReportedPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::ReportedPx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ReportedPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ReportedPx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ReportedPx'.\n  Possible C/C++ prototypes are:\n    FIX::ReportedPx()\n    FIX::ReportedPx(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSymbol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LegSymbol *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSymbol(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegSymbol__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegSymbol'.\n  Possible C/C++ prototypes are:\n    FIX::LegSymbol()\n    FIX::LegSymbol(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegIssuer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LegIssuer *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegIssuer(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegIssuer__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegIssuer'.\n  Possible C/C++ prototypes are:\n    FIX::LegIssuer()\n    FIX::LegIssuer(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistDetls__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::RegistDetls *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistDetls(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RegistDetls__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RegistDetls'.\n  Possible C/C++ prototypes are:\n    FIX::RegistDetls()\n    FIX::RegistDetls(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingLegSecurityID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingLegSecurityID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingLegSecurityID'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingLegSecurityID()\n    FIX::UnderlyingLegSecurityID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MinLotSize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::MinLotSize *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MinLotSize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MinLotSize__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MinLotSize'.\n  Possible C/C++ prototypes are:\n    FIX::MinLotSize()\n    FIX::MinLotSize(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NumTickets__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::NumTickets *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NumTickets(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NumTickets__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NumTickets'.\n  Possible C/C++ prototypes are:\n    FIX::NumTickets()\n    FIX::NumTickets(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegLocaleOfIssue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LegLocaleOfIssue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegLocaleOfIssue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegLocaleOfIssue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegLocaleOfIssue'.\n  Possible C/C++ prototypes are:\n    FIX::LegLocaleOfIssue()\n    FIX::LegLocaleOfIssue(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExchangeForPhysical__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::ExchangeForPhysical *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExchangeForPhysical(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ExchangeForPhysical__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ExchangeForPhysical'.\n  Possible C/C++ prototypes are:\n    FIX::ExchangeForPhysical()\n    FIX::ExchangeForPhysical(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityTradingEvent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::SecurityTradingEvent *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityTradingEvent(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecurityTradingEvent__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecurityTradingEvent'.\n  Possible C/C++ prototypes are:\n    FIX::SecurityTradingEvent()\n    FIX::SecurityTradingEvent(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MinPriceIncrementAmount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::MinPriceIncrementAmount *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MinPriceIncrementAmount(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MinPriceIncrementAmount__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MinPriceIncrementAmount'.\n  Possible C/C++ prototypes are:\n    FIX::MinPriceIncrementAmount()\n    FIX::MinPriceIncrementAmount(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingPayAmount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::UnderlyingPayAmount *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingPayAmount(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingPayAmount__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingPayAmount'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingPayAmount()\n    FIX::UnderlyingPayAmount(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlPartySubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SettlPartySubID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlPartySubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlPartySubID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlPartySubID'.\n  Possible C/C++ prototypes are:\n    FIX::SettlPartySubID()\n    FIX::SettlPartySubID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocNetMoney__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::AllocNetMoney *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocNetMoney(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllocNetMoney__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllocNetMoney'.\n  Possible C/C++ prototypes are:\n    FIX::AllocNetMoney()\n    FIX::AllocNetMoney(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingMaturityDay__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DAYOFMONTH *arg1 = 0 ;
  FIX::UnderlyingMaturityDay *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingMaturityDay(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingMaturityDay__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingMaturityDay'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingMaturityDay()\n    FIX::UnderlyingMaturityDay(FIX::DAYOFMONTH const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetworkResponseID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::NetworkResponseID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetworkResponseID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NetworkResponseID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NetworkResponseID'.\n  Possible C/C++ prototypes are:\n    FIX::NetworkResponseID()\n    FIX::NetworkResponseID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NumBidders__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::NumBidders *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NumBidders(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NumBidders__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NumBidders'.\n  Possible C/C++ prototypes are:\n    FIX::NumBidders()\n    FIX::NumBidders(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocAcctIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::AllocAcctIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocAcctIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllocAcctIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllocAcctIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::AllocAcctIDSource()\n    FIX::AllocAcctIDSource(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocAvgPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::AllocAvgPx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocAvgPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllocAvgPx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllocAvgPx'.\n  Possible C/C++ prototypes are:\n    FIX::AllocAvgPx()\n    FIX::AllocAvgPx(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecuritySettlAgentCode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SecuritySettlAgentCode *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecuritySettlAgentCode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecuritySettlAgentCode__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecuritySettlAgentCode'.\n  Possible C/C++ prototypes are:\n    FIX::SecuritySettlAgentCode()\n    FIX::SecuritySettlAgentCode(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoDistribInsts__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoDistribInsts *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoDistribInsts(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoDistribInsts__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoDistribInsts'.\n  Possible C/C++ prototypes are:\n    FIX::NoDistribInsts()\n    FIX::NoDistribInsts(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CustDirectedOrder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::CustDirectedOrder *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CustDirectedOrder(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CustDirectedOrder__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CustDirectedOrder'.\n  Possible C/C++ prototypes are:\n    FIX::CustDirectedOrder()\n    FIX::CustDirectedOrder(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FairValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::FairValue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FairValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_FairValue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_FairValue'.\n  Possible C/C++ prototypes are:\n    FIX::FairValue()\n    FIX::FairValue(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoStrikes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoStrikes *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoStrikes(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoStrikes__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoStrikes'.\n  Possible C/C++ prototypes are:\n    FIX::NoStrikes()\n    FIX::NoStrikes(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedSecurityListDescLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  FIX::EncodedSecurityListDescLen *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedSecurityListDescLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncodedSecurityListDescLen__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncodedSecurityListDescLen'.\n  Possible C/C++ prototypes are:\n    FIX::EncodedSecurityListDescLen()\n    FIX::EncodedSecurityListDescLen(FIX::LENGTH const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegExerciseStyle__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::LegExerciseStyle *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegExerciseStyle(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegExerciseStyle__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegExerciseStyle'.\n  Possible C/C++ prototypes are:\n    FIX::LegExerciseStyle()\n    FIX::LegExerciseStyle(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSymbolSfx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DerivativeSymbolSfx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSymbolSfx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeSymbolSfx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeSymbolSfx'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeSymbolSfx()\n    FIX::DerivativeSymbolSfx(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NestedInstrAttribType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::NestedInstrAttribType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NestedInstrAttribType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NestedInstrAttribType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NestedInstrAttribType'.\n  Possible C/C++ prototypes are:\n    FIX::NestedInstrAttribType()\n    FIX::NestedInstrAttribType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContraTrader__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ContraTrader *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContraTrader(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ContraTrader__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ContraTrader'.\n  Possible C/C++ prototypes are:\n    FIX::ContraTrader()\n    FIX::ContraTrader(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RiskInstrumentSettlType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskInstrumentSettlType *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RiskInstrumentSettlType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskInstrumentSettlType *)new FIX::RiskInstrumentSettlType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskInstrumentSettlType, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RiskInstrumentSettlType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RiskInstrumentSettlType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskInstrumentSettlType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskInstrumentSettlType'.\n  Possible C/C++ prototypes are:\n    FIX::RiskInstrumentSettlType()\n    FIX::RiskInstrumentSettlType(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RiskInstrumentSettlType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RiskInstrumentSettlType, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDSecSize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::MDSecSize *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDSecSize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MDSecSize__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MDSecSize'.\n  Possible C/C++ prototypes are:\n    FIX::MDSecSize()\n    FIX::MDSecSize(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoOfSecSizes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoOfSecSizes *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoOfSecSizes(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoOfSecSizes__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoOfSecSizes'.\n  Possible C/C++ prototypes are:\n    FIX::NoOfSecSizes()\n    FIX::NoOfSecSizes(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollAction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::CollAction *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollAction(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CollAction__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CollAction'.\n  Possible C/C++ prototypes are:\n    FIX::CollAction()\n    FIX::CollAction(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLastQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::UnderlyingLastQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLastQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingLastQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingLastQty'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingLastQty()\n    FIX::UnderlyingLastQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PossDupFlag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::PossDupFlag *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PossDupFlag(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PossDupFlag__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PossDupFlag'.\n  Possible C/C++ prototypes are:\n    FIX::PossDupFlag()\n    FIX::PossDupFlag(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListStatusType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ListStatusType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListStatusType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ListStatusType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ListStatusType'.\n  Possible C/C++ prototypes are:\n    FIX::ListStatusType()\n    FIX::ListStatusType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideFillStationCd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SideFillStationCd *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideFillStationCd(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SideFillStationCd__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SideFillStationCd'.\n  Possible C/C++ prototypes are:\n    FIX::SideFillStationCd()\n    FIX::SideFillStationCd(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StatusText__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::StatusText *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StatusText(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StatusText__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StatusText'.\n  Possible C/C++ prototypes are:\n    FIX::StatusText()\n    FIX::StatusText(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BasisFeatureDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::BasisFeatureDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BasisFeatureDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_BasisFeatureDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BasisFeatureDate'.\n  Possible C/C++ prototypes are:\n    FIX::BasisFeatureDate()\n    FIX::BasisFeatureDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XmlDataLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  FIX::XmlDataLen *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XmlDataLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_XmlDataLen__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_XmlDataLen'.\n  Possible C/C++ prototypes are:\n    FIX::XmlDataLen()\n    FIX::XmlDataLen(FIX::LENGTH const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingMaturityDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::UnderlyingMaturityDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingMaturityDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingMaturityDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingMaturityDate'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingMaturityDate()\n    FIX::UnderlyingMaturityDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GapFillFlag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::GapFillFlag *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GapFillFlag(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_GapFillFlag__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_GapFillFlag'.\n  Possible C/C++ prototypes are:\n    FIX::GapFillFlag()\n    FIX::GapFillFlag(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefApplExtID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::RefApplExtID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefApplExtID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RefApplExtID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RefApplExtID'.\n  Possible C/C++ prototypes are:\n    FIX::RefApplExtID()\n    FIX::RefApplExtID(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefApplID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::RefApplID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefApplID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RefApplID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RefApplID'.\n  Possible C/C++ prototypes are:\n    FIX::RefApplID()\n    FIX::RefApplID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTradingSessionRules__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoTradingSessionRules *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTradingSessionRules(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoTradingSessionRules__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoTradingSessionRules'.\n  Possible C/C++ prototypes are:\n    FIX::NoTradingSessionRules()\n    FIX::NoTradingSessionRules(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  FIX::SwapPoints *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapPoints(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SwapPoints__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SwapPoints'.\n  Possible C/C++ prototypes are:\n    FIX::SwapPoints()\n    FIX::SwapPoints(FIX::PRICEOFFSET const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetStrategyParameters__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::TargetStrategyParameters *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetStrategyParameters(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TargetStrategyParameters__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TargetStrategyParameters'.\n  Possible C/C++ prototypes are:\n    FIX::TargetStrategyParameters()\n    FIX::TargetStrategyParameters(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastForwardPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  FIX::LastForwardPoints *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastForwardPoints(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LastForwardPoints__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LastForwardPoints'.\n  Possible C/C++ prototypes are:\n    FIX::LastForwardPoints()\n    FIX::LastForwardPoints(FIX::PRICEOFFSET const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YieldRedemptionDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::YieldRedemptionDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YieldRedemptionDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_YieldRedemptionDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_YieldRedemptionDate'.\n  Possible C/C++ prototypes are:\n    FIX::YieldRedemptionDate()\n    FIX::YieldRedemptionDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelationshipRiskSecurityID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelationshipRiskSecurityID *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelationshipRiskSecurityID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskSecurityID *)new FIX::RelationshipRiskSecurityID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskSecurityID, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RelationshipRiskSecurityID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelationshipRiskSecurityID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelationshipRiskSecurityID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelationshipRiskSecurityID'.\n  Possible C/C++ prototypes are:\n    FIX::RelationshipRiskSecurityID()\n    FIX::RelationshipRiskSecurityID(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelationshipRiskSecurityID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelationshipRiskSecurityID, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSettlDetails__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoSettlDetails *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSettlDetails(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoSettlDetails__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoSettlDetails'.\n  Possible C/C++ prototypes are:\n    FIX::NoSettlDetails()\n    FIX::NoSettlDetails(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeHandlingInstr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::TradeHandlingInstr *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeHandlingInstr(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradeHandlingInstr__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradeHandlingInstr'.\n  Possible C/C++ prototypes are:\n    FIX::TradeHandlingInstr()\n    FIX::TradeHandlingInstr(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashSettlAgentCode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::CashSettlAgentCode *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashSettlAgentCode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CashSettlAgentCode__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CashSettlAgentCode'.\n  Possible C/C++ prototypes are:\n    FIX::CashSettlAgentCode()\n    FIX::CashSettlAgentCode(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegPriceType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::LegPriceType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegPriceType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegPriceType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegPriceType'.\n  Possible C/C++ prototypes are:\n    FIX::LegPriceType()\n    FIX::LegPriceType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedListExecInstLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  FIX::EncodedListExecInstLen *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedListExecInstLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncodedListExecInstLen__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncodedListExecInstLen'.\n  Possible C/C++ prototypes are:\n    FIX::EncodedListExecInstLen()\n    FIX::EncodedListExecInstLen(FIX::LENGTH const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TradSesMethod *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradSesMethod__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradSesMethod'.\n  Possible C/C++ prototypes are:\n    FIX::TradSesMethod()\n    FIX::TradSesMethod(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RiskLimitCurrency__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskLimitCurrency *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RiskLimitCurrency")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskLimitCurrency *)new FIX::RiskLimitCurrency();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskLimitCurrency, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RiskLimitCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  FIX::RiskLimitCurrency *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_RiskLimitCurrency",&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_RiskLimitCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RiskLimitCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskLimitCurrency *)new FIX::RiskLimitCurrency((FIX::CURRENCY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskLimitCurrency, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RiskLimitCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RiskLimitCurrency__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskLimitCurrency__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskLimitCurrency'.\n  Possible C/C++ prototypes are:\n    FIX::RiskLimitCurrency()\n    FIX::RiskLimitCurrency(FIX::CURRENCY const &)\n");
  return NULL;
}


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


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

SWIGINTERN PyObject *_wrap_new_PartyDetailsListRequestID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PartyDetailsListRequestID *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_PartyDetailsListRequestID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PartyDetailsListRequestID *)new FIX::PartyDetailsListRequestID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PartyDetailsListRequestID, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_PartyDetailsListRequestID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_PartyDetailsListRequestID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PartyDetailsListRequestID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PartyDetailsListRequestID'.\n  Possible C/C++ prototypes are:\n    FIX::PartyDetailsListRequestID()\n    FIX::PartyDetailsListRequestID(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *PartyDetailsListRequestID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PartyDetailsListRequestID, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AgreementID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::AgreementID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AgreementID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AgreementID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AgreementID'.\n  Possible C/C++ prototypes are:\n    FIX::AgreementID()\n    FIX::AgreementID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashDistribCurr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  FIX::CashDistribCurr *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashDistribCurr(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CashDistribCurr__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CashDistribCurr'.\n  Possible C/C++ prototypes are:\n    FIX::CashDistribCurr()\n    FIX::CashDistribCurr(FIX::CURRENCY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::BidPx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_BidPx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BidPx'.\n  Possible C/C++ prototypes are:\n    FIX::BidPx()\n    FIX::BidPx(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::TradeType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradeType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradeType'.\n  Possible C/C++ prototypes are:\n    FIX::TradeType()\n    FIX::TradeType(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedSecurityDescLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  FIX::EncodedSecurityDescLen *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedSecurityDescLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncodedSecurityDescLen__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncodedSecurityDescLen'.\n  Possible C/C++ prototypes are:\n    FIX::EncodedSecurityDescLen()\n    FIX::EncodedSecurityDescLen(FIX::LENGTH const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventCondition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ComplexEventCondition *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventCondition(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ComplexEventCondition__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ComplexEventCondition'.\n  Possible C/C++ prototypes are:\n    FIX::ComplexEventCondition()\n    FIX::ComplexEventCondition(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncryptedPasswordMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::EncryptedPasswordMethod *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncryptedPasswordMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncryptedPasswordMethod__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncryptedPasswordMethod'.\n  Possible C/C++ prototypes are:\n    FIX::EncryptedPasswordMethod()\n    FIX::EncryptedPasswordMethod(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityAltID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DerivativeSecurityAltID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityAltID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeSecurityAltID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeSecurityAltID'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeSecurityAltID()\n    FIX::DerivativeSecurityAltID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoAccQuotes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TotNoAccQuotes *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoAccQuotes(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TotNoAccQuotes__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TotNoAccQuotes'.\n  Possible C/C++ prototypes are:\n    FIX::TotNoAccQuotes()\n    FIX::TotNoAccQuotes(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeBracket__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::TimeBracket *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeBracket(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TimeBracket__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TimeBracket'.\n  Possible C/C++ prototypes are:\n    FIX::TimeBracket()\n    FIX::TimeBracket(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoAllocs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoAllocs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoAllocs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoAllocs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoAllocs'.\n  Possible C/C++ prototypes are:\n    FIX::NoAllocs()\n    FIX::NoAllocs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingProduct__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::UnderlyingProduct *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingProduct(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingProduct__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingProduct'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingProduct()\n    FIX::UnderlyingProduct(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BenchmarkCurveName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::BenchmarkCurveName *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BenchmarkCurveName(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_BenchmarkCurveName__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BenchmarkCurveName'.\n  Possible C/C++ prototypes are:\n    FIX::BenchmarkCurveName()\n    FIX::BenchmarkCurveName(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSymbolSfx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingSymbolSfx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSymbolSfx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingSymbolSfx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingSymbolSfx'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingSymbolSfx()\n    FIX::UnderlyingSymbolSfx(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikePriceBoundaryPrecision__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::StrikePriceBoundaryPrecision *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikePriceBoundaryPrecision(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StrikePriceBoundaryPrecision__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StrikePriceBoundaryPrecision'.\n  Possible C/C++ prototypes are:\n    FIX::StrikePriceBoundaryPrecision()\n    FIX::StrikePriceBoundaryPrecision(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteSetID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::QuoteSetID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteSetID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_QuoteSetID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_QuoteSetID'.\n  Possible C/C++ prototypes are:\n    FIX::QuoteSetID()\n    FIX::QuoteSetID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashMargin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::CashMargin *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashMargin(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CashMargin__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CashMargin'.\n  Possible C/C++ prototypes are:\n    FIX::CashMargin()\n    FIX::CashMargin(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlObligTransType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::SettlObligTransType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlObligTransType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlObligTransType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlObligTransType'.\n  Possible C/C++ prototypes are:\n    FIX::SettlObligTransType()\n    FIX::SettlObligTransType(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegNumber__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::LegNumber *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegNumber(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegNumber__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegNumber'.\n  Possible C/C++ prototypes are:\n    FIX::LegNumber()\n    FIX::LegNumber(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeskOrderHandlingInst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MULTIPLESTRINGVALUE *arg1 = 0 ;
  FIX::DeskOrderHandlingInst *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeskOrderHandlingInst(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DeskOrderHandlingInst__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DeskOrderHandlingInst'.\n  Possible C/C++ prototypes are:\n    FIX::DeskOrderHandlingInst()\n    FIX::DeskOrderHandlingInst(FIX::MULTIPLESTRINGVALUE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlPartyIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::SettlPartyIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlPartyIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlPartyIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlPartyIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::SettlPartyIDSource()\n    FIX::SettlPartyIDSource(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriorSettlPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::PriorSettlPrice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriorSettlPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PriorSettlPrice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PriorSettlPrice'.\n  Possible C/C++ prototypes are:\n    FIX::PriorSettlPrice()\n    FIX::PriorSettlPrice(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelationshipRiskSecurityType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelationshipRiskSecurityType *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelationshipRiskSecurityType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskSecurityType *)new FIX::RelationshipRiskSecurityType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskSecurityType, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RelationshipRiskSecurityType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelationshipRiskSecurityType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelationshipRiskSecurityType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelationshipRiskSecurityType'.\n  Possible C/C++ prototypes are:\n    FIX::RelationshipRiskSecurityType()\n    FIX::RelationshipRiskSecurityType(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelationshipRiskSecurityType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelationshipRiskSecurityType, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NotAffOrigClOrdID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::NotAffOrigClOrdID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NotAffOrigClOrdID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NotAffOrigClOrdID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NotAffOrigClOrdID'.\n  Possible C/C++ prototypes are:\n    FIX::NotAffOrigClOrdID()\n    FIX::NotAffOrigClOrdID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradingSessionDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::TradingSessionDesc *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradingSessionDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradingSessionDesc__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradingSessionDesc'.\n  Possible C/C++ prototypes are:\n    FIX::TradingSessionDesc()\n    FIX::TradingSessionDesc(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeFloorPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::DerivativeFloorPrice *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeFloorPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeFloorPrice__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeFloorPrice'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeFloorPrice()\n    FIX::DerivativeFloorPrice(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSymbol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DerivativeSymbol *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSymbol(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeSymbol__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeSymbol'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeSymbol()\n    FIX::DerivativeSymbol(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RiskFreeRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::RiskFreeRate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RiskFreeRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskFreeRate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskFreeRate'.\n  Possible C/C++ prototypes are:\n    FIX::RiskFreeRate()\n    FIX::RiskFreeRate(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosTransType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::PosTransType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosTransType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PosTransType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PosTransType'.\n  Possible C/C++ prototypes are:\n    FIX::PosTransType()\n    FIX::PosTransType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MsgSeqNum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SEQNUM *arg1 = 0 ;
  FIX::MsgSeqNum *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MsgSeqNum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MsgSeqNum__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MsgSeqNum'.\n  Possible C/C++ prototypes are:\n    FIX::MsgSeqNum()\n    FIX::MsgSeqNum(FIX::SEQNUM const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Signature__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  FIX::Signature *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Signature(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Signature__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Signature'.\n  Possible C/C++ prototypes are:\n    FIX::Signature()\n    FIX::Signature(FIX::DATA const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Seniority__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::Seniority *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Seniority(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Seniority__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Seniority'.\n  Possible C/C++ prototypes are:\n    FIX::Seniority()\n    FIX::Seniority(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRateSources__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRateSources *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRateSources(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoRateSources__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoRateSources'.\n  Possible C/C++ prototypes are:\n    FIX::NoRateSources()\n    FIX::NoRateSources(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriceUnitOfMeasureQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::PriceUnitOfMeasureQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriceUnitOfMeasureQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PriceUnitOfMeasureQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PriceUnitOfMeasureQty'.\n  Possible C/C++ prototypes are:\n    FIX::PriceUnitOfMeasureQty()\n    FIX::PriceUnitOfMeasureQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollAsgnRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::CollAsgnRefID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollAsgnRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CollAsgnRefID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CollAsgnRefID'.\n  Possible C/C++ prototypes are:\n    FIX::CollAsgnRefID()\n    FIX::CollAsgnRefID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BuyVolume__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::BuyVolume *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BuyVolume(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_BuyVolume__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BuyVolume'.\n  Possible C/C++ prototypes are:\n    FIX::BuyVolume()\n    FIX::BuyVolume(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlCurrFxRateCalc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::SettlCurrFxRateCalc *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlCurrFxRateCalc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlCurrFxRateCalc__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlCurrFxRateCalc'.\n  Possible C/C++ prototypes are:\n    FIX::SettlCurrFxRateCalc()\n    FIX::SettlCurrFxRateCalc(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosMaintStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::PosMaintStatus *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosMaintStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PosMaintStatus__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PosMaintStatus'.\n  Possible C/C++ prototypes are:\n    FIX::PosMaintStatus()\n    FIX::PosMaintStatus(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriorSpreadIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::PriorSpreadIndicator *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriorSpreadIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PriorSpreadIndicator__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PriorSpreadIndicator'.\n  Possible C/C++ prototypes are:\n    FIX::PriorSpreadIndicator()\n    FIX::PriorSpreadIndicator(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Benchmark__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::Benchmark *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Benchmark(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Benchmark__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Benchmark'.\n  Possible C/C++ prototypes are:\n    FIX::Benchmark()\n    FIX::Benchmark(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityMonthYearFormat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::MaturityMonthYearFormat *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityMonthYearFormat(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MaturityMonthYearFormat__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MaturityMonthYearFormat'.\n  Possible C/C++ prototypes are:\n    FIX::MaturityMonthYearFormat()\n    FIX::MaturityMonthYearFormat(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingTradingSessionID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingTradingSessionID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingTradingSessionID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingTradingSessionID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingTradingSessionID'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingTradingSessionID()\n    FIX::UnderlyingTradingSessionID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoRelatedSym__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TotNoRelatedSym *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoRelatedSym(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TotNoRelatedSym__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TotNoRelatedSym'.\n  Possible C/C++ prototypes are:\n    FIX::TotNoRelatedSym()\n    FIX::TotNoRelatedSym(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StateOrProvinceOfIssue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::StateOrProvinceOfIssue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StateOrProvinceOfIssue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StateOrProvinceOfIssue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StateOrProvinceOfIssue'.\n  Possible C/C++ prototypes are:\n    FIX::StateOrProvinceOfIssue()\n    FIX::StateOrProvinceOfIssue(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelatedPartyAltSubID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelatedPartyAltSubID *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelatedPartyAltSubID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelatedPartyAltSubID *)new FIX::RelatedPartyAltSubID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelatedPartyAltSubID, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RelatedPartyAltSubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelatedPartyAltSubID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelatedPartyAltSubID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelatedPartyAltSubID'.\n  Possible C/C++ prototypes are:\n    FIX::RelatedPartyAltSubID()\n    FIX::RelatedPartyAltSubID(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelatedPartyAltSubID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelatedPartyAltSubID, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrRegistry__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DerivativeInstrRegistry *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrRegistry(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeInstrRegistry__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeInstrRegistry'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeInstrRegistry()\n    FIX::DerivativeInstrRegistry(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegBidForwardPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  FIX::LegBidForwardPoints *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegBidForwardPoints(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegBidForwardPoints__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegBidForwardPoints'.\n  Possible C/C++ prototypes are:\n    FIX::LegBidForwardPoints()\n    FIX::LegBidForwardPoints(FIX::PRICEOFFSET const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ManualOrderIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::ManualOrderIndicator *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ManualOrderIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ManualOrderIndicator__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ManualOrderIndicator'.\n  Possible C/C++ prototypes are:\n    FIX::ManualOrderIndicator()\n    FIX::ManualOrderIndicator(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetMoney__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::NetMoney *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetMoney(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NetMoney__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NetMoney'.\n  Possible C/C++ prototypes are:\n    FIX::NetMoney()\n    FIX::NetMoney(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegalConfirm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::LegalConfirm *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegalConfirm(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegalConfirm__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegalConfirm'.\n  Possible C/C++ prototypes are:\n    FIX::LegalConfirm()\n    FIX::LegalConfirm(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CountryOfIssue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::COUNTRY *arg1 = 0 ;
  FIX::CountryOfIssue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CountryOfIssue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CountryOfIssue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CountryOfIssue'.\n  Possible C/C++ prototypes are:\n    FIX::CountryOfIssue()\n    FIX::CountryOfIssue(FIX::COUNTRY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplReportType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ApplReportType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplReportType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ApplReportType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ApplReportType'.\n  Possible C/C++ prototypes are:\n    FIX::ApplReportType()\n    FIX::ApplReportType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RootPartyID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::RootPartyID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RootPartyID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RootPartyID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RootPartyID'.\n  Possible C/C++ prototypes are:\n    FIX::RootPartyID()\n    FIX::RootPartyID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::UnderlyingQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingQty'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingQty()\n    FIX::UnderlyingQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplQueueDepth__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ApplQueueDepth *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplQueueDepth(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ApplQueueDepth__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ApplQueueDepth'.\n  Possible C/C++ prototypes are:\n    FIX::ApplQueueDepth()\n    FIX::ApplQueueDepth(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StopPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::StopPx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StopPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StopPx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StopPx'.\n  Possible C/C++ prototypes are:\n    FIX::StopPx()\n    FIX::StopPx(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ReportToExch__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::ReportToExch *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ReportToExch(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ReportToExch__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ReportToExch'.\n  Possible C/C++ prototypes are:\n    FIX::ReportToExch()\n    FIX::ReportToExch(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContraryInstructionIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::ContraryInstructionIndicator *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContraryInstructionIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ContraryInstructionIndicator__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ContraryInstructionIndicator'.\n  Possible C/C++ prototypes are:\n    FIX::ContraryInstructionIndicator()\n    FIX::ContraryInstructionIndicator(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedListStatusTextLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  FIX::EncodedListStatusTextLen *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedListStatusTextLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncodedListStatusTextLen__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncodedListStatusTextLen'.\n  Possible C/C++ prototypes are:\n    FIX::EncodedListStatusTextLen()\n    FIX::EncodedListStatusTextLen(FIX::LENGTH const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityXMLSchema__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DerivativeSecurityXMLSchema *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityXMLSchema(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeSecurityXMLSchema__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeSecurityXMLSchema'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeSecurityXMLSchema()\n    FIX::DerivativeSecurityXMLSchema(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRelatedSym__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRelatedSym *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRelatedSym(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoRelatedSym__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoRelatedSym'.\n  Possible C/C++ prototypes are:\n    FIX::NoRelatedSym()\n    FIX::NoRelatedSym(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocRejCode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::AllocRejCode *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocRejCode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllocRejCode__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllocRejCode'.\n  Possible C/C++ prototypes are:\n    FIX::AllocRejCode()\n    FIX::AllocRejCode(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityAltID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingSecurityAltID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityAltID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingSecurityAltID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingSecurityAltID'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingSecurityAltID()\n    FIX::UnderlyingSecurityAltID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_NoRelationshipRiskSecurityAltID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoRelationshipRiskSecurityAltID *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_NoRelationshipRiskSecurityAltID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRelationshipRiskSecurityAltID *)new FIX::NoRelationshipRiskSecurityAltID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRelationshipRiskSecurityAltID, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRelationshipRiskSecurityAltID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRelationshipRiskSecurityAltID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoRelationshipRiskSecurityAltID",&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_NoRelationshipRiskSecurityAltID" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoRelationshipRiskSecurityAltID" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRelationshipRiskSecurityAltID *)new FIX::NoRelationshipRiskSecurityAltID((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRelationshipRiskSecurityAltID, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRelationshipRiskSecurityAltID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_NoRelationshipRiskSecurityAltID__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoRelationshipRiskSecurityAltID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoRelationshipRiskSecurityAltID'.\n  Possible C/C++ prototypes are:\n    FIX::NoRelationshipRiskSecurityAltID()\n    FIX::NoRelationshipRiskSecurityAltID(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *NoRelationshipRiskSecurityAltID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoRelationshipRiskSecurityAltID, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefOrdIDReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::RefOrdIDReason *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefOrdIDReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RefOrdIDReason__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RefOrdIDReason'.\n  Possible C/C++ prototypes are:\n    FIX::RefOrdIDReason()\n    FIX::RefOrdIDReason(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrumentPartyID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DerivativeInstrumentPartyID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrumentPartyID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeInstrumentPartyID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeInstrumentPartyID'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeInstrumentPartyID()\n    FIX::DerivativeInstrumentPartyID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityXMLSchema__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SecurityXMLSchema *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityXMLSchema(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecurityXMLSchema__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecurityXMLSchema'.\n  Possible C/C++ prototypes are:\n    FIX::SecurityXMLSchema()\n    FIX::SecurityXMLSchema(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefOrderIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::RefOrderIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefOrderIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RefOrderIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RefOrderIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::RefOrderIDSource()\n    FIX::RefOrderIDSource(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NTPositionLimit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::NTPositionLimit *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NTPositionLimit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NTPositionLimit__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NTPositionLimit'.\n  Possible C/C++ prototypes are:\n    FIX::NTPositionLimit()\n    FIX::NTPositionLimit(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EndAccruedInterestAmt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::EndAccruedInterestAmt *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EndAccruedInterestAmt(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EndAccruedInterestAmt__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EndAccruedInterestAmt'.\n  Possible C/C++ prototypes are:\n    FIX::EndAccruedInterestAmt()\n    FIX::EndAccruedInterestAmt(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AccruedInterestRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::AccruedInterestRate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AccruedInterestRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AccruedInterestRate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AccruedInterestRate'.\n  Possible C/C++ prototypes are:\n    FIX::AccruedInterestRate()\n    FIX::AccruedInterestRate(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastCapacity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::LastCapacity *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastCapacity(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LastCapacity__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LastCapacity'.\n  Possible C/C++ prototypes are:\n    FIX::LastCapacity()\n    FIX::LastCapacity(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelationshipRiskLimitCurrency__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelationshipRiskLimitCurrency *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelationshipRiskLimitCurrency")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskLimitCurrency *)new FIX::RelationshipRiskLimitCurrency();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskLimitCurrency, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelationshipRiskLimitCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  FIX::RelationshipRiskLimitCurrency *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_RelationshipRiskLimitCurrency",&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_RelationshipRiskLimitCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RelationshipRiskLimitCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskLimitCurrency *)new FIX::RelationshipRiskLimitCurrency((FIX::CURRENCY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskLimitCurrency, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelationshipRiskLimitCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelationshipRiskLimitCurrency__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelationshipRiskLimitCurrency__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelationshipRiskLimitCurrency'.\n  Possible C/C++ prototypes are:\n    FIX::RelationshipRiskLimitCurrency()\n    FIX::RelationshipRiskLimitCurrency(FIX::CURRENCY const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelationshipRiskLimitCurrency_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelationshipRiskLimitCurrency, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingInstrumentPartySubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingInstrumentPartySubID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingInstrumentPartySubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingInstrumentPartySubID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingInstrumentPartySubID'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingInstrumentPartySubID()\n    FIX::UnderlyingInstrumentPartySubID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoFills__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoFills *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoFills(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoFills__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoFills'.\n  Possible C/C++ prototypes are:\n    FIX::NoFills()\n    FIX::NoFills(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoOrdTypeRules__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoOrdTypeRules *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoOrdTypeRules(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoOrdTypeRules__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoOrdTypeRules'.\n  Possible C/C++ prototypes are:\n    FIX::NoOrdTypeRules()\n    FIX::NoOrdTypeRules(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrumentPartyID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::InstrumentPartyID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrumentPartyID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_InstrumentPartyID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_InstrumentPartyID'.\n  Possible C/C++ prototypes are:\n    FIX::InstrumentPartyID()\n    FIX::InstrumentPartyID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarginRatio__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::MarginRatio *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarginRatio(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MarginRatio__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MarginRatio'.\n  Possible C/C++ prototypes are:\n    FIX::MarginRatio()\n    FIX::MarginRatio(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefTagID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::RefTagID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefTagID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RefTagID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RefTagID'.\n  Possible C/C++ prototypes are:\n    FIX::RefTagID()\n    FIX::RefTagID(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRoutingIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRoutingIDs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRoutingIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoRoutingIDs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoRoutingIDs'.\n  Possible C/C++ prototypes are:\n    FIX::NoRoutingIDs()\n    FIX::NoRoutingIDs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CouponRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::CouponRate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CouponRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CouponRate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CouponRate'.\n  Possible C/C++ prototypes are:\n    FIX::CouponRate()\n    FIX::CouponRate(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoApplIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoApplIDs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoApplIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoApplIDs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoApplIDs'.\n  Possible C/C++ prototypes are:\n    FIX::NoApplIDs()\n    FIX::NoApplIDs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeContractSettlMonth__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MONTHYEAR *arg1 = 0 ;
  FIX::DerivativeContractSettlMonth *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeContractSettlMonth(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeContractSettlMonth__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeContractSettlMonth'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeContractSettlMonth()\n    FIX::DerivativeContractSettlMonth(FIX::MONTHYEAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrAttribType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::InstrAttribType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrAttribType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_InstrAttribType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_InstrAttribType'.\n  Possible C/C++ prototypes are:\n    FIX::InstrAttribType()\n    FIX::InstrAttribType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Product__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::Product *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Product(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Product__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Product'.\n  Possible C/C++ prototypes are:\n    FIX::Product()\n    FIX::Product(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocShares__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::AllocShares *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocShares(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllocShares__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllocShares'.\n  Possible C/C++ prototypes are:\n    FIX::AllocShares()\n    FIX::AllocShares(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoQuoteEntries__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoQuoteEntries *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoQuoteEntries(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoQuoteEntries__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoQuoteEntries'.\n  Possible C/C++ prototypes are:\n    FIX::NoQuoteEntries()\n    FIX::NoQuoteEntries(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelationshipRiskWarningLevelName__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelationshipRiskWarningLevelName *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelationshipRiskWarningLevelName")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskWarningLevelName *)new FIX::RelationshipRiskWarningLevelName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskWarningLevelName, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RelationshipRiskWarningLevelName(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelationshipRiskWarningLevelName__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelationshipRiskWarningLevelName__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelationshipRiskWarningLevelName'.\n  Possible C/C++ prototypes are:\n    FIX::RelationshipRiskWarningLevelName()\n    FIX::RelationshipRiskWarningLevelName(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelationshipRiskWarningLevelName_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelationshipRiskWarningLevelName, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefaultCstmApplVerID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DefaultCstmApplVerID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefaultCstmApplVerID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DefaultCstmApplVerID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DefaultCstmApplVerID'.\n  Possible C/C++ prototypes are:\n    FIX::DefaultCstmApplVerID()\n    FIX::DefaultCstmApplVerID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeListMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::DerivativeListMethod *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeListMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeListMethod__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeListMethod'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeListMethod()\n    FIX::DerivativeListMethod(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityXMLLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  FIX::DerivativeSecurityXMLLen *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityXMLLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeSecurityXMLLen__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeSecurityXMLLen'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeSecurityXMLLen()\n    FIX::DerivativeSecurityXMLLen(FIX::LENGTH const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegDatedDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::LegDatedDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegDatedDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegDatedDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegDatedDate'.\n  Possible C/C++ prototypes are:\n    FIX::LegDatedDate()\n    FIX::LegDatedDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested2PartyIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::Nested2PartyIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested2PartyIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Nested2PartyIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Nested2PartyIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::Nested2PartyIDSource()\n    FIX::Nested2PartyIDSource(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingInstrRegistry__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingInstrRegistry *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingInstrRegistry(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingInstrRegistry__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingInstrRegistry'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingInstrRegistry()\n    FIX::UnderlyingInstrRegistry(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IssueDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::IssueDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IssueDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_IssueDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_IssueDate'.\n  Possible C/C++ prototypes are:\n    FIX::IssueDate()\n    FIX::IssueDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityTradingStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::SecurityTradingStatus *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityTradingStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecurityTradingStatus__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecurityTradingStatus'.\n  Possible C/C++ prototypes are:\n    FIX::SecurityTradingStatus()\n    FIX::SecurityTradingStatus(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegOptAttribute__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::LegOptAttribute *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegOptAttribute(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegOptAttribute__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegOptAttribute'.\n  Possible C/C++ prototypes are:\n    FIX::LegOptAttribute()\n    FIX::LegOptAttribute(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaxFloor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::MaxFloor *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaxFloor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MaxFloor__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MaxFloor'.\n  Possible C/C++ prototypes are:\n    FIX::MaxFloor()\n    FIX::MaxFloor(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeLocaleOfIssue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DerivativeLocaleOfIssue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeLocaleOfIssue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeLocaleOfIssue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeLocaleOfIssue'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeLocaleOfIssue()\n    FIX::DerivativeLocaleOfIssue(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OptPayAmount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::OptPayAmount *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OptPayAmount(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OptPayAmount__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OptPayAmount'.\n  Possible C/C++ prototypes are:\n    FIX::OptPayAmount()\n    FIX::OptPayAmount(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingStipType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingStipType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingStipType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingStipType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingStipType'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingStipType()\n    FIX::UnderlyingStipType(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Rule80A__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::Rule80A *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Rule80A(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Rule80A__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Rule80A'.\n  Possible C/C++ prototypes are:\n    FIX::Rule80A()\n    FIX::Rule80A(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoStrikes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TotNoStrikes *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoStrikes(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TotNoStrikes__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TotNoStrikes'.\n  Possible C/C++ prototypes are:\n    FIX::TotNoStrikes()\n    FIX::TotNoStrikes(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CorporateAction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MULTIPLECHARVALUE *arg1 = 0 ;
  FIX::CorporateAction *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CorporateAction(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CorporateAction__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CorporateAction'.\n  Possible C/C++ prototypes are:\n    FIX::CorporateAction()\n    FIX::CorporateAction(FIX::MULTIPLECHARVALUE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TerminationType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TerminationType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TerminationType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TerminationType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TerminationType'.\n  Possible C/C++ prototypes are:\n    FIX::TerminationType()\n    FIX::TerminationType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCouponRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::LegCouponRate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCouponRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegCouponRate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegCouponRate'.\n  Possible C/C++ prototypes are:\n    FIX::LegCouponRate()\n    FIX::LegCouponRate(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosMaintAction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::PosMaintAction *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosMaintAction(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PosMaintAction__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PosMaintAction'.\n  Possible C/C++ prototypes are:\n    FIX::PosMaintAction()\n    FIX::PosMaintAction(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSecurityTypes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoSecurityTypes *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSecurityTypes(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoSecurityTypes__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoSecurityTypes'.\n  Possible C/C++ prototypes are:\n    FIX::NoSecurityTypes()\n    FIX::NoSecurityTypes(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventPriceTimeType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ComplexEventPriceTimeType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventPriceTimeType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ComplexEventPriceTimeType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ComplexEventPriceTimeType'.\n  Possible C/C++ prototypes are:\n    FIX::ComplexEventPriceTimeType()\n    FIX::ComplexEventPriceTimeType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastSwapPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  FIX::LastSwapPoints *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastSwapPoints(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LastSwapPoints__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LastSwapPoints'.\n  Possible C/C++ prototypes are:\n    FIX::LastSwapPoints()\n    FIX::LastSwapPoints(FIX::PRICEOFFSET const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingFXRateCalc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::UnderlyingFXRateCalc *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingFXRateCalc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingFXRateCalc__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingFXRateCalc'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingFXRateCalc()\n    FIX::UnderlyingFXRateCalc(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListStatusText__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ListStatusText *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListStatusText(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ListStatusText__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ListStatusText'.\n  Possible C/C++ prototypes are:\n    FIX::ListStatusText()\n    FIX::ListStatusText(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OddLot__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::OddLot *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OddLot(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OddLot__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OddLot'.\n  Possible C/C++ prototypes are:\n    FIX::OddLot()\n    FIX::OddLot(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BookingUnit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::BookingUnit *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BookingUnit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_BookingUnit__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BookingUnit'.\n  Possible C/C++ prototypes are:\n    FIX::BookingUnit()\n    FIX::BookingUnit(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegAllocAcctIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LegAllocAcctIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegAllocAcctIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegAllocAcctIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegAllocAcctIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::LegAllocAcctIDSource()\n    FIX::LegAllocAcctIDSource(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OnBehalfOfSendingTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  FIX::OnBehalfOfSendingTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OnBehalfOfSendingTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  FIX::OnBehalfOfSendingTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OnBehalfOfSendingTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  FIX::OnBehalfOfSendingTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OnBehalfOfSendingTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_new_OnBehalfOfSendingTime__SWIG_3(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OnBehalfOfSendingTime'.\n  Possible C/C++ prototypes are:\n    FIX::OnBehalfOfSendingTime()\n    FIX::OnBehalfOfSendingTime(bool)\n    FIX::OnBehalfOfSendingTime(FIX::UTCTIMESTAMP const &)\n    FIX::OnBehalfOfSendingTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::AllocStatus *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AllocStatus__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AllocStatus'.\n  Possible C/C++ prototypes are:\n    FIX::AllocStatus()\n    FIX::AllocStatus(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ReferencePage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ReferencePage *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ReferencePage(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ReferencePage__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ReferencePage'.\n  Possible C/C++ prototypes are:\n    FIX::ReferencePage()\n    FIX::ReferencePage(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeExerciseStyle__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::DerivativeExerciseStyle *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeExerciseStyle(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeExerciseStyle__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeExerciseStyle'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeExerciseStyle()\n    FIX::DerivativeExerciseStyle(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplBegSeqNum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SEQNUM *arg1 = 0 ;
  FIX::ApplBegSeqNum *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplBegSeqNum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ApplBegSeqNum__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ApplBegSeqNum'.\n  Possible C/C++ prototypes are:\n    FIX::ApplBegSeqNum()\n    FIX::ApplBegSeqNum(FIX::SEQNUM const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollRptID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::CollRptID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollRptID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CollRptID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CollRptID'.\n  Possible C/C++ prototypes are:\n    FIX::CollRptID()\n    FIX::CollRptID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IncTaxInd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::IncTaxInd *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IncTaxInd(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_IncTaxInd__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_IncTaxInd'.\n  Possible C/C++ prototypes are:\n    FIX::IncTaxInd()\n    FIX::IncTaxInd(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoBidDescriptors__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoBidDescriptors *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoBidDescriptors(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoBidDescriptors__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoBidDescriptors'.\n  Possible C/C++ prototypes are:\n    FIX::NoBidDescriptors()\n    FIX::NoBidDescriptors(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCouponPaymentDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::LegCouponPaymentDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCouponPaymentDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegCouponPaymentDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegCouponPaymentDate'.\n  Possible C/C++ prototypes are:\n    FIX::LegCouponPaymentDate()\n    FIX::LegCouponPaymentDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_TotNoPartyList__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotNoPartyList *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_TotNoPartyList")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotNoPartyList *)new FIX::TotNoPartyList();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotNoPartyList, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_TotNoPartyList(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_TotNoPartyList__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TotNoPartyList__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TotNoPartyList'.\n  Possible C/C++ prototypes are:\n    FIX::TotNoPartyList()\n    FIX::TotNoPartyList(FIX::INT const &)\n");
  return NULL;
}


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


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

SWIGINTERN PyObject *_wrap_new_PartyListResponseType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PartyListResponseType *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_PartyListResponseType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PartyListResponseType *)new FIX::PartyListResponseType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PartyListResponseType, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_PartyListResponseType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_PartyListResponseType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PartyListResponseType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PartyListResponseType'.\n  Possible C/C++ prototypes are:\n    FIX::PartyListResponseType()\n    FIX::PartyListResponseType(FIX::INT const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *PartyListResponseType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PartyListResponseType, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoUnderlyingLegSecurityAltID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoUnderlyingLegSecurityAltID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoUnderlyingLegSecurityAltID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoUnderlyingLegSecurityAltID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoUnderlyingLegSecurityAltID'.\n  Possible C/C++ prototypes are:\n    FIX::NoUnderlyingLegSecurityAltID()\n    FIX::NoUnderlyingLegSecurityAltID(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ReversalIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::ReversalIndicator *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ReversalIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ReversalIndicator__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ReversalIndicator'.\n  Possible C/C++ prototypes are:\n    FIX::ReversalIndicator()\n    FIX::ReversalIndicator(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CheckSum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::CheckSum *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CheckSum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CheckSum__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CheckSum'.\n  Possible C/C++ prototypes are:\n    FIX::CheckSum()\n    FIX::CheckSum(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetSubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::TargetSubID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetSubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TargetSubID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TargetSubID'.\n  Possible C/C++ prototypes are:\n    FIX::TargetSubID()\n    FIX::TargetSubID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosReqStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::PosReqStatus *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosReqStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PosReqStatus__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PosReqStatus'.\n  Possible C/C++ prototypes are:\n    FIX::PosReqStatus()\n    FIX::PosReqStatus(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriorityIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::PriorityIndicator *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriorityIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PriorityIndicator__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PriorityIndicator'.\n  Possible C/C++ prototypes are:\n    FIX::PriorityIndicator()\n    FIX::PriorityIndicator(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_ContextPartySubIDType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContextPartySubIDType *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_ContextPartySubIDType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContextPartySubIDType *)new FIX::ContextPartySubIDType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContextPartySubIDType, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_ContextPartySubIDType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_ContextPartySubIDType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ContextPartySubIDType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ContextPartySubIDType'.\n  Possible C/C++ prototypes are:\n    FIX::ContextPartySubIDType()\n    FIX::ContextPartySubIDType(FIX::INT const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *ContextPartySubIDType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ContextPartySubIDType, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegCFICode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingLegCFICode *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegCFICode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingLegCFICode__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingLegCFICode'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingLegCFICode()\n    FIX::UnderlyingLegCFICode(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeTimeUnit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DerivativeTimeUnit *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeTimeUnit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeTimeUnit__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeTimeUnit'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeTimeUnit()\n    FIX::DerivativeTimeUnit(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNested3PartyIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoNested3PartyIDs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNested3PartyIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoNested3PartyIDs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoNested3PartyIDs'.\n  Possible C/C++ prototypes are:\n    FIX::NoNested3PartyIDs()\n    FIX::NoNested3PartyIDs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LiquidityPctHigh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::LiquidityPctHigh *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LiquidityPctHigh(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LiquidityPctHigh__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LiquidityPctHigh'.\n  Possible C/C++ prototypes are:\n    FIX::LiquidityPctHigh()\n    FIX::LiquidityPctHigh(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MoneyLaunderingStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::MoneyLaunderingStatus *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MoneyLaunderingStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MoneyLaunderingStatus__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MoneyLaunderingStatus'.\n  Possible C/C++ prototypes are:\n    FIX::MoneyLaunderingStatus()\n    FIX::MoneyLaunderingStatus(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested4PartySubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::Nested4PartySubID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested4PartySubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Nested4PartySubID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Nested4PartySubID'.\n  Possible C/C++ prototypes are:\n    FIX::Nested4PartySubID()\n    FIX::Nested4PartySubID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityExchange__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EXCHANGE *arg1 = 0 ;
  FIX::DerivativeSecurityExchange *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityExchange(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeSecurityExchange__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeSecurityExchange'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeSecurityExchange()\n    FIX::DerivativeSecurityExchange(FIX::EXCHANGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LotType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::LotType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LotType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LotType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LotType'.\n  Possible C/C++ prototypes are:\n    FIX::LotType()\n    FIX::LotType(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContIntRptID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ContIntRptID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContIntRptID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ContIntRptID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ContIntRptID'.\n  Possible C/C++ prototypes are:\n    FIX::ContIntRptID()\n    FIX::ContIntRptID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteCondition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MULTIPLESTRINGVALUE *arg1 = 0 ;
  FIX::QuoteCondition *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteCondition(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_QuoteCondition__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_QuoteCondition'.\n  Possible C/C++ prototypes are:\n    FIX::QuoteCondition()\n    FIX::QuoteCondition(FIX::MULTIPLESTRINGVALUE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventStartTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMEONLY *arg1 = 0 ;
  FIX::ComplexEventStartTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventStartTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ComplexEventStartTime__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ComplexEventStartTime'.\n  Possible C/C++ prototypes are:\n    FIX::ComplexEventStartTime()\n    FIX::ComplexEventStartTime(FIX::UTCTIMEONLY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoComplexEvents__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoComplexEvents *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoComplexEvents(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoComplexEvents__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoComplexEvents'.\n  Possible C/C++ prototypes are:\n    FIX::NoComplexEvents()\n    FIX::NoComplexEvents(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeContractMultiplier__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::DerivativeContractMultiplier *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeContractMultiplier(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeContractMultiplier__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeContractMultiplier'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeContractMultiplier()\n    FIX::DerivativeContractMultiplier(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DerivativeSecurityStatus *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeSecurityStatus__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeSecurityStatus'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeSecurityStatus()\n    FIX::DerivativeSecurityStatus(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeProductComplex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DerivativeProductComplex *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeProductComplex(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeProductComplex__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeProductComplex'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeProductComplex()\n    FIX::DerivativeProductComplex(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerSymbol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::TriggerSymbol *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerSymbol(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TriggerSymbol__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TriggerSymbol'.\n  Possible C/C++ prototypes are:\n    FIX::TriggerSymbol()\n    FIX::TriggerSymbol(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLocaleOfIssue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingLocaleOfIssue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLocaleOfIssue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingLocaleOfIssue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingLocaleOfIssue'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingLocaleOfIssue()\n    FIX::UnderlyingLocaleOfIssue(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SendingTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  FIX::SendingTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SendingTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  FIX::SendingTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SendingTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  FIX::SendingTime *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SendingTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_new_SendingTime__SWIG_3(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SendingTime'.\n  Possible C/C++ prototypes are:\n    FIX::SendingTime()\n    FIX::SendingTime(bool)\n    FIX::SendingTime(FIX::UTCTIMESTAMP const &)\n    FIX::SendingTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelationshipRiskMaturityMonthYear__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelationshipRiskMaturityMonthYear *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelationshipRiskMaturityMonthYear")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskMaturityMonthYear *)new FIX::RelationshipRiskMaturityMonthYear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskMaturityMonthYear, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelationshipRiskMaturityMonthYear__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MONTHYEAR *arg1 = 0 ;
  FIX::RelationshipRiskMaturityMonthYear *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_RelationshipRiskMaturityMonthYear",&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_RelationshipRiskMaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RelationshipRiskMaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::MONTHYEAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskMaturityMonthYear *)new FIX::RelationshipRiskMaturityMonthYear((FIX::MONTHYEAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskMaturityMonthYear, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelationshipRiskMaturityMonthYear(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelationshipRiskMaturityMonthYear__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelationshipRiskMaturityMonthYear__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelationshipRiskMaturityMonthYear'.\n  Possible C/C++ prototypes are:\n    FIX::RelationshipRiskMaturityMonthYear()\n    FIX::RelationshipRiskMaturityMonthYear(FIX::MONTHYEAR const &)\n");
  return NULL;
}


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


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

SWIGINTERN PyObject *_wrap_new_RelatedPartyAltIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelatedPartyAltIDSource *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelatedPartyAltIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelatedPartyAltIDSource *)new FIX::RelatedPartyAltIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelatedPartyAltIDSource, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelatedPartyAltIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::RelatedPartyAltIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_RelatedPartyAltIDSource",&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_RelatedPartyAltIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RelatedPartyAltIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelatedPartyAltIDSource *)new FIX::RelatedPartyAltIDSource((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelatedPartyAltIDSource, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelatedPartyAltIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelatedPartyAltIDSource__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelatedPartyAltIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelatedPartyAltIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::RelatedPartyAltIDSource()\n    FIX::RelatedPartyAltIDSource(FIX::CHAR const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelatedPartyAltIDSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelatedPartyAltIDSource, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventStartDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  FIX::ComplexEventStartDate *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventStartDate__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  FIX::ComplexEventStartDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventStartDate__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  FIX::ComplexEventStartDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventStartDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_new_ComplexEventStartDate__SWIG_3(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ComplexEventStartDate'.\n  Possible C/C++ prototypes are:\n    FIX::ComplexEventStartDate()\n    FIX::ComplexEventStartDate(bool)\n    FIX::ComplexEventStartDate(FIX::UTCTIMESTAMP const &)\n    FIX::ComplexEventStartDate(FIX::UTCTIMESTAMP const &,bool)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingRestructuringType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingRestructuringType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingRestructuringType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingRestructuringType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingRestructuringType'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingRestructuringType()\n    FIX::UnderlyingRestructuringType(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegUnitOfMeasureQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::LegUnitOfMeasureQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegUnitOfMeasureQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegUnitOfMeasureQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegUnitOfMeasureQty'.\n  Possible C/C++ prototypes are:\n    FIX::LegUnitOfMeasureQty()\n    FIX::LegUnitOfMeasureQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTrdRegTimestamps__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoTrdRegTimestamps *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTrdRegTimestamps(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoTrdRegTimestamps__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoTrdRegTimestamps'.\n  Possible C/C++ prototypes are:\n    FIX::NoTrdRegTimestamps()\n    FIX::NoTrdRegTimestamps(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SendingDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::SendingDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SendingDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SendingDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SendingDate'.\n  Possible C/C++ prototypes are:\n    FIX::SendingDate()\n    FIX::SendingDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_PartyRelationship__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PartyRelationship *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_PartyRelationship")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PartyRelationship *)new FIX::PartyRelationship();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PartyRelationship, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_PartyRelationship(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_PartyRelationship__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_PartyRelationship__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PartyRelationship'.\n  Possible C/C++ prototypes are:\n    FIX::PartyRelationship()\n    FIX::PartyRelationship(FIX::INT const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *PartyRelationship_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PartyRelationship, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeToExpiration__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::TimeToExpiration *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeToExpiration(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TimeToExpiration__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TimeToExpiration'.\n  Possible C/C++ prototypes are:\n    FIX::TimeToExpiration()\n    FIX::TimeToExpiration(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegAllocQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::LegAllocQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegAllocQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegAllocQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegAllocQty'.\n  Possible C/C++ prototypes are:\n    FIX::LegAllocQty()\n    FIX::LegAllocQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlLocation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SettlLocation *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlLocation(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlLocation__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlLocation'.\n  Possible C/C++ prototypes are:\n    FIX::SettlLocation()\n    FIX::SettlLocation(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingExerciseStyle__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::UnderlyingExerciseStyle *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingExerciseStyle(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingExerciseStyle__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingExerciseStyle'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingExerciseStyle()\n    FIX::UnderlyingExerciseStyle(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashSettlAgentContactName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::CashSettlAgentContactName *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashSettlAgentContactName(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CashSettlAgentContactName__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CashSettlAgentContactName'.\n  Possible C/C++ prototypes are:\n    FIX::CashSettlAgentContactName()\n    FIX::CashSettlAgentContactName(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegRepurchaseRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::LegRepurchaseRate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegRepurchaseRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegRepurchaseRate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegRepurchaseRate'.\n  Possible C/C++ prototypes are:\n    FIX::LegRepurchaseRate()\n    FIX::LegRepurchaseRate(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplResponseID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ApplResponseID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplResponseID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ApplResponseID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ApplResponseID'.\n  Possible C/C++ prototypes are:\n    FIX::ApplResponseID()\n    FIX::ApplResponseID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoDerivativeInstrAttrib__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoDerivativeInstrAttrib *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoDerivativeInstrAttrib(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoDerivativeInstrAttrib__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoDerivativeInstrAttrib'.\n  Possible C/C++ prototypes are:\n    FIX::NoDerivativeInstrAttrib()\n    FIX::NoDerivativeInstrAttrib(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeStrikeMultiplier__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::DerivativeStrikeMultiplier *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeStrikeMultiplier(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeStrikeMultiplier__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeStrikeMultiplier'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeStrikeMultiplier()\n    FIX::DerivativeStrikeMultiplier(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegStrikeCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  FIX::LegStrikeCurrency *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegStrikeCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegStrikeCurrency__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegStrikeCurrency'.\n  Possible C/C++ prototypes are:\n    FIX::LegStrikeCurrency()\n    FIX::LegStrikeCurrency(FIX::CURRENCY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityStatusReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SecurityStatusReqID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityStatusReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecurityStatusReqID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecurityStatusReqID'.\n  Possible C/C++ prototypes are:\n    FIX::SecurityStatusReqID()\n    FIX::SecurityStatusReqID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecureDataLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  FIX::SecureDataLen *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecureDataLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecureDataLen__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecureDataLen'.\n  Possible C/C++ prototypes are:\n    FIX::SecureDataLen()\n    FIX::SecureDataLen(FIX::LENGTH const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionScope__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::DiscretionScope *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionScope(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DiscretionScope__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DiscretionScope'.\n  Possible C/C++ prototypes are:\n    FIX::DiscretionScope()\n    FIX::DiscretionScope(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OwnerType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::OwnerType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OwnerType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OwnerType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OwnerType'.\n  Possible C/C++ prototypes are:\n    FIX::OwnerType()\n    FIX::OwnerType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Shares__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::Shares *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Shares(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Shares__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Shares'.\n  Possible C/C++ prototypes are:\n    FIX::Shares()\n    FIX::Shares(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Yield__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::Yield *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Yield(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Yield__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Yield'.\n  Possible C/C++ prototypes are:\n    FIX::Yield()\n    FIX::Yield(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteRespID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::QuoteRespID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteRespID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_QuoteRespID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_QuoteRespID'.\n  Possible C/C++ prototypes are:\n    FIX::QuoteRespID()\n    FIX::QuoteRespID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RiskMaturityMonthYear__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskMaturityMonthYear *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RiskMaturityMonthYear")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskMaturityMonthYear *)new FIX::RiskMaturityMonthYear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskMaturityMonthYear, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RiskMaturityMonthYear__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MONTHYEAR *arg1 = 0 ;
  FIX::RiskMaturityMonthYear *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_RiskMaturityMonthYear",&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_RiskMaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RiskMaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::MONTHYEAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskMaturityMonthYear *)new FIX::RiskMaturityMonthYear((FIX::MONTHYEAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskMaturityMonthYear, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RiskMaturityMonthYear(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RiskMaturityMonthYear__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskMaturityMonthYear__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskMaturityMonthYear'.\n  Possible C/C++ prototypes are:\n    FIX::RiskMaturityMonthYear()\n    FIX::RiskMaturityMonthYear(FIX::MONTHYEAR const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RiskMaturityMonthYear_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RiskMaturityMonthYear, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested3PartySubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::Nested3PartySubID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested3PartySubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Nested3PartySubID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Nested3PartySubID'.\n  Possible C/C++ prototypes are:\n    FIX::Nested3PartySubID()\n    FIX::Nested3PartySubID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplQueueResolution__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ApplQueueResolution *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplQueueResolution(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ApplQueueResolution__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ApplQueueResolution'.\n  Possible C/C++ prototypes are:\n    FIX::ApplQueueResolution()\n    FIX::ApplQueueResolution(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdRegTimestampOrigin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::TrdRegTimestampOrigin *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdRegTimestampOrigin(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TrdRegTimestampOrigin__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TrdRegTimestampOrigin'.\n  Possible C/C++ prototypes are:\n    FIX::TrdRegTimestampOrigin()\n    FIX::TrdRegTimestampOrigin(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested2PartyRole__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::Nested2PartyRole *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested2PartyRole(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Nested2PartyRole__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Nested2PartyRole'.\n  Possible C/C++ prototypes are:\n    FIX::Nested2PartyRole()\n    FIX::Nested2PartyRole(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested2PartyID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::Nested2PartyID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested2PartyID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Nested2PartyID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Nested2PartyID'.\n  Possible C/C++ prototypes are:\n    FIX::Nested2PartyID()\n    FIX::Nested2PartyID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidSize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::BidSize *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidSize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_BidSize__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BidSize'.\n  Possible C/C++ prototypes are:\n    FIX::BidSize()\n    FIX::BidSize(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSymbolSfx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::LegSymbolSfx *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSymbolSfx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegSymbolSfx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegSymbolSfx'.\n  Possible C/C++ prototypes are:\n    FIX::LegSymbolSfx()\n    FIX::LegSymbolSfx(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteResponseLevel__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::QuoteResponseLevel *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteResponseLevel(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_QuoteResponseLevel__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_QuoteResponseLevel'.\n  Possible C/C++ prototypes are:\n    FIX::QuoteResponseLevel()\n    FIX::QuoteResponseLevel(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BodyLength__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  FIX::BodyLength *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BodyLength(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_BodyLength__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BodyLength'.\n  Possible C/C++ prototypes are:\n    FIX::BodyLength()\n    FIX::BodyLength(FIX::LENGTH const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListExecInst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ListExecInst *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListExecInst(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ListExecInst__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ListExecInst'.\n  Possible C/C++ prototypes are:\n    FIX::ListExecInst()\n    FIX::ListExecInst(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecAckStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::ExecAckStatus *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecAckStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ExecAckStatus__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ExecAckStatus'.\n  Possible C/C++ prototypes are:\n    FIX::ExecAckStatus()\n    FIX::ExecAckStatus(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlDate2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::SettlDate2 *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlDate2(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlDate2__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlDate2'.\n  Possible C/C++ prototypes are:\n    FIX::SettlDate2()\n    FIX::SettlDate2(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetGrossInd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::NetGrossInd *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetGrossInd(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NetGrossInd__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NetGrossInd'.\n  Possible C/C++ prototypes are:\n    FIX::NetGrossInd()\n    FIX::NetGrossInd(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityAltIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingSecurityAltIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityAltIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingSecurityAltIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingSecurityAltIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingSecurityAltIDSource()\n    FIX::UnderlyingSecurityAltIDSource(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TestReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::TestReqID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TestReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TestReqID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TestReqID'.\n  Possible C/C++ prototypes are:\n    FIX::TestReqID()\n    FIX::TestReqID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CxlType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::CxlType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CxlType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CxlType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CxlType'.\n  Possible C/C++ prototypes are:\n    FIX::CxlType()\n    FIX::CxlType(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCreditRating__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingCreditRating *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCreditRating(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingCreditRating__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingCreditRating'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingCreditRating()\n    FIX::UnderlyingCreditRating(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AvgPxPrecision__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::AvgPxPrecision *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AvgPxPrecision(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AvgPxPrecision__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AvgPxPrecision'.\n  Possible C/C++ prototypes are:\n    FIX::AvgPxPrecision()\n    FIX::AvgPxPrecision(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BenchmarkPriceType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::BenchmarkPriceType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BenchmarkPriceType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_BenchmarkPriceType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BenchmarkPriceType'.\n  Possible C/C++ prototypes are:\n    FIX::BenchmarkPriceType()\n    FIX::BenchmarkPriceType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeskTypeSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::DeskTypeSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeskTypeSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DeskTypeSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DeskTypeSource'.\n  Possible C/C++ prototypes are:\n    FIX::DeskTypeSource()\n    FIX::DeskTypeSource(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionRoundDirection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::DiscretionRoundDirection *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionRoundDirection(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DiscretionRoundDirection__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DiscretionRoundDirection'.\n  Possible C/C++ prototypes are:\n    FIX::DiscretionRoundDirection()\n    FIX::DiscretionRoundDirection(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigSecondaryTradeID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::OrigSecondaryTradeID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigSecondaryTradeID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OrigSecondaryTradeID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OrigSecondaryTradeID'.\n  Possible C/C++ prototypes are:\n    FIX::OrigSecondaryTradeID()\n    FIX::OrigSecondaryTradeID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ReceivedDeptID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::ReceivedDeptID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ReceivedDeptID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ReceivedDeptID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ReceivedDeptID'.\n  Possible C/C++ prototypes are:\n    FIX::ReceivedDeptID()\n    FIX::ReceivedDeptID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityNetMoney__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  FIX::MaturityNetMoney *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityNetMoney(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MaturityNetMoney__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MaturityNetMoney'.\n  Possible C/C++ prototypes are:\n    FIX::MaturityNetMoney()\n    FIX::MaturityNetMoney(FIX::AMT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidDescriptorType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::BidDescriptorType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidDescriptorType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_BidDescriptorType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BidDescriptorType'.\n  Possible C/C++ prototypes are:\n    FIX::BidDescriptorType()\n    FIX::BidDescriptorType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RiskEncodedSecurityDescLen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskEncodedSecurityDescLen *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RiskEncodedSecurityDescLen")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskEncodedSecurityDescLen *)new FIX::RiskEncodedSecurityDescLen();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskEncodedSecurityDescLen, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RiskEncodedSecurityDescLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  FIX::RiskEncodedSecurityDescLen *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_RiskEncodedSecurityDescLen",&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_RiskEncodedSecurityDescLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RiskEncodedSecurityDescLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskEncodedSecurityDescLen *)new FIX::RiskEncodedSecurityDescLen((FIX::LENGTH const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskEncodedSecurityDescLen, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RiskEncodedSecurityDescLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RiskEncodedSecurityDescLen__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskEncodedSecurityDescLen__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskEncodedSecurityDescLen'.\n  Possible C/C++ prototypes are:\n    FIX::RiskEncodedSecurityDescLen()\n    FIX::RiskEncodedSecurityDescLen(FIX::LENGTH const &)\n");
  return NULL;
}


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


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

SWIGINTERN PyObject *_wrap_new_RelationshipRiskSymbol__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelationshipRiskSymbol *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelationshipRiskSymbol")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskSymbol *)new FIX::RelationshipRiskSymbol();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskSymbol, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RelationshipRiskSymbol(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelationshipRiskSymbol__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelationshipRiskSymbol__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelationshipRiskSymbol'.\n  Possible C/C++ prototypes are:\n    FIX::RelationshipRiskSymbol()\n    FIX::RelationshipRiskSymbol(FIX::STRING const &)\n");
  return NULL;
}


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


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

SWIGINTERN PyObject *_wrap_new_NoRelatedContextPartyIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoRelatedContextPartyIDs *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_NoRelatedContextPartyIDs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRelatedContextPartyIDs *)new FIX::NoRelatedContextPartyIDs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRelatedContextPartyIDs, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRelatedContextPartyIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRelatedContextPartyIDs *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoRelatedContextPartyIDs",&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_NoRelatedContextPartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoRelatedContextPartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRelatedContextPartyIDs *)new FIX::NoRelatedContextPartyIDs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRelatedContextPartyIDs, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRelatedContextPartyIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_NoRelatedContextPartyIDs__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoRelatedContextPartyIDs__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoRelatedContextPartyIDs'.\n  Possible C/C++ prototypes are:\n    FIX::NoRelatedContextPartyIDs()\n    FIX::NoRelatedContextPartyIDs(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *NoRelatedContextPartyIDs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoRelatedContextPartyIDs, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrumentPartySubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::DerivativeInstrumentPartySubID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrumentPartySubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativeInstrumentPartySubID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativeInstrumentPartySubID'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativeInstrumentPartySubID()\n    FIX::DerivativeInstrumentPartySubID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetworkStatusResponseType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::NetworkStatusResponseType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetworkStatusResponseType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NetworkStatusResponseType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NetworkStatusResponseType'.\n  Possible C/C++ prototypes are:\n    FIX::NetworkStatusResponseType()\n    FIX::NetworkStatusResponseType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DateOfBirth__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::DateOfBirth *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DateOfBirth(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DateOfBirth__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DateOfBirth'.\n  Possible C/C++ prototypes are:\n    FIX::DateOfBirth()\n    FIX::DateOfBirth(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelatedContextPartySubIDType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelatedContextPartySubIDType *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelatedContextPartySubIDType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelatedContextPartySubIDType *)new FIX::RelatedContextPartySubIDType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelatedContextPartySubIDType, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RelatedContextPartySubIDType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelatedContextPartySubIDType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelatedContextPartySubIDType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelatedContextPartySubIDType'.\n  Possible C/C++ prototypes are:\n    FIX::RelatedContextPartySubIDType()\n    FIX::RelatedContextPartySubIDType(FIX::INT const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelatedContextPartySubIDType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelatedContextPartySubIDType, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StartStrikePxRange__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  FIX::StartStrikePxRange *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StartStrikePxRange(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StartStrikePxRange__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StartStrikePxRange'.\n  Possible C/C++ prototypes are:\n    FIX::StartStrikePxRange()\n    FIX::StartStrikePxRange(FIX::PRICE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndlyInstrumentPartySubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UndlyInstrumentPartySubID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndlyInstrumentPartySubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UndlyInstrumentPartySubID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UndlyInstrumentPartySubID'.\n  Possible C/C++ prototypes are:\n    FIX::UndlyInstrumentPartySubID()\n    FIX::UndlyInstrumentPartySubID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryTradeReportRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::SecondaryTradeReportRefID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryTradeReportRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SecondaryTradeReportRefID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SecondaryTradeReportRefID'.\n  Possible C/C++ prototypes are:\n    FIX::SecondaryTradeReportRefID()\n    FIX::SecondaryTradeReportRefID(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCPRegType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingCPRegType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCPRegType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingCPRegType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingCPRegType'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingCPRegType()\n    FIX::UnderlyingCPRegType(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SignatureLength__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  FIX::SignatureLength *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SignatureLength(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SignatureLength__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SignatureLength'.\n  Possible C/C++ prototypes are:\n    FIX::SignatureLength()\n    FIX::SignatureLength(FIX::LENGTH const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  FIX::OrderQty *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OrderQty__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OrderQty'.\n  Possible C/C++ prototypes are:\n    FIX::OrderQty()\n    FIX::OrderQty(FIX::QTY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelationshipRiskWarningLevelPercent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelationshipRiskWarningLevelPercent *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelationshipRiskWarningLevelPercent")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskWarningLevelPercent *)new FIX::RelationshipRiskWarningLevelPercent();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskWarningLevelPercent, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelationshipRiskWarningLevelPercent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::RelationshipRiskWarningLevelPercent *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_RelationshipRiskWarningLevelPercent",&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_RelationshipRiskWarningLevelPercent" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RelationshipRiskWarningLevelPercent" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskWarningLevelPercent *)new FIX::RelationshipRiskWarningLevelPercent((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskWarningLevelPercent, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelationshipRiskWarningLevelPercent(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelationshipRiskWarningLevelPercent__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelationshipRiskWarningLevelPercent__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelationshipRiskWarningLevelPercent'.\n  Possible C/C++ prototypes are:\n    FIX::RelationshipRiskWarningLevelPercent()\n    FIX::RelationshipRiskWarningLevelPercent(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelationshipRiskWarningLevelPercent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelationshipRiskWarningLevelPercent, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OriginalNotionalPercentageOutstanding__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::OriginalNotionalPercentageOutstanding *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OriginalNotionalPercentageOutstanding(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_OriginalNotionalPercentageOutstanding__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OriginalNotionalPercentageOutstanding'.\n  Possible C/C++ prototypes are:\n    FIX::OriginalNotionalPercentageOutstanding()\n    FIX::OriginalNotionalPercentageOutstanding(FIX::PERCENTAGE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingTimeUnit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingTimeUnit *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingTimeUnit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingTimeUnit__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingTimeUnit'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingTimeUnit()\n    FIX::UnderlyingTimeUnit(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedHeadlineLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  FIX::EncodedHeadlineLen *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedHeadlineLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncodedHeadlineLen__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncodedHeadlineLen'.\n  Possible C/C++ prototypes are:\n    FIX::EncodedHeadlineLen()\n    FIX::EncodedHeadlineLen(FIX::LENGTH const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRegistDtls__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRegistDtls *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRegistDtls(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoRegistDtls__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoRegistDtls'.\n  Possible C/C++ prototypes are:\n    FIX::NoRegistDtls()\n    FIX::NoRegistDtls(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrategyParameterValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::StrategyParameterValue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrategyParameterValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StrategyParameterValue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StrategyParameterValue'.\n  Possible C/C++ prototypes are:\n    FIX::StrategyParameterValue()\n    FIX::StrategyParameterValue(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RiskSecurityDesc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskSecurityDesc *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RiskSecurityDesc")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskSecurityDesc *)new FIX::RiskSecurityDesc();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskSecurityDesc, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RiskSecurityDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RiskSecurityDesc__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskSecurityDesc__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskSecurityDesc'.\n  Possible C/C++ prototypes are:\n    FIX::RiskSecurityDesc()\n    FIX::RiskSecurityDesc(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RiskSecurityDesc_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RiskSecurityDesc, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoInstrumentParties__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoInstrumentParties *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoInstrumentParties(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoInstrumentParties__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoInstrumentParties'.\n  Possible C/C++ prototypes are:\n    FIX::NoInstrumentParties()\n    FIX::NoInstrumentParties(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::QuoteType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_QuoteType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_QuoteType'.\n  Possible C/C++ prototypes are:\n    FIX::QuoteType()\n    FIX::QuoteType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_NoRiskSecurityAltID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoRiskSecurityAltID *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_NoRiskSecurityAltID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRiskSecurityAltID *)new FIX::NoRiskSecurityAltID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRiskSecurityAltID, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRiskSecurityAltID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRiskSecurityAltID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoRiskSecurityAltID",&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_NoRiskSecurityAltID" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoRiskSecurityAltID" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRiskSecurityAltID *)new FIX::NoRiskSecurityAltID((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRiskSecurityAltID, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRiskSecurityAltID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_NoRiskSecurityAltID__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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoRiskSecurityAltID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoRiskSecurityAltID'.\n  Possible C/C++ prototypes are:\n    FIX::NoRiskSecurityAltID()\n    FIX::NoRiskSecurityAltID(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *NoRiskSecurityAltID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoRiskSecurityAltID, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoStrategyParameters__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoStrategyParameters *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoStrategyParameters(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_NoStrategyParameters__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NoStrategyParameters'.\n  Possible C/C++ prototypes are:\n    FIX::NoStrategyParameters()\n    FIX::NoStrategyParameters(FIX::NUMINGROUP const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IndividualAllocRejCode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::IndividualAllocRejCode *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IndividualAllocRejCode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_IndividualAllocRejCode__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_IndividualAllocRejCode'.\n  Possible C/C++ prototypes are:\n    FIX::IndividualAllocRejCode()\n    FIX::IndividualAllocRejCode(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionInst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::DiscretionInst *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionInst(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DiscretionInst__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DiscretionInst'.\n  Possible C/C++ prototypes are:\n    FIX::DiscretionInst()\n    FIX::DiscretionInst(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RiskSecurityAltID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskSecurityAltID *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RiskSecurityAltID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskSecurityAltID *)new FIX::RiskSecurityAltID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskSecurityAltID, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RiskSecurityAltID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RiskSecurityAltID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RiskSecurityAltID__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RiskSecurityAltID'.\n  Possible C/C++ prototypes are:\n    FIX::RiskSecurityAltID()\n    FIX::RiskSecurityAltID(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RiskSecurityAltID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RiskSecurityAltID, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetPartyRole__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::TargetPartyRole *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetPartyRole(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TargetPartyRole__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TargetPartyRole'.\n  Possible C/C++ prototypes are:\n    FIX::TargetPartyRole()\n    FIX::TargetPartyRole(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CrossPrioritization__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::CrossPrioritization *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CrossPrioritization(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_CrossPrioritization__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CrossPrioritization'.\n  Possible C/C++ prototypes are:\n    FIX::CrossPrioritization()\n    FIX::CrossPrioritization(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedListStatusText__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  FIX::EncodedListStatusText *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedListStatusText(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_EncodedListStatusText__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncodedListStatusText'.\n  Possible C/C++ prototypes are:\n    FIX::EncodedListStatusText()\n    FIX::EncodedListStatusText(FIX::DATA const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOIOthSvc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::IOIOthSvc *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOIOthSvc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_IOIOthSvc__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_IOIOthSvc'.\n  Possible C/C++ prototypes are:\n    FIX::IOIOthSvc()\n    FIX::IOIOthSvc(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegIssueDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::LegIssueDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegIssueDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_LegIssueDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LegIssueDate'.\n  Possible C/C++ prototypes are:\n    FIX::LegIssueDate()\n    FIX::LegIssueDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDReqRejReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  FIX::MDReqRejReason *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDReqRejReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_MDReqRejReason__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MDReqRejReason'.\n  Possible C/C++ prototypes are:\n    FIX::MDReqRejReason()\n    FIX::MDReqRejReason(FIX::CHAR const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelationshipRiskPutOrCall__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelationshipRiskPutOrCall *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelationshipRiskPutOrCall")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskPutOrCall *)new FIX::RelationshipRiskPutOrCall();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskPutOrCall, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RelationshipRiskPutOrCall(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelationshipRiskPutOrCall__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelationshipRiskPutOrCall__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelationshipRiskPutOrCall'.\n  Possible C/C++ prototypes are:\n    FIX::RelationshipRiskPutOrCall()\n    FIX::RelationshipRiskPutOrCall(FIX::INT const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelationshipRiskPutOrCall_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelationshipRiskPutOrCall, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplReqType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::ApplReqType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplReqType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ApplReqType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ApplReqType'.\n  Possible C/C++ prototypes are:\n    FIX::ApplReqType()\n    FIX::ApplReqType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Country__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::COUNTRY *arg1 = 0 ;
  FIX::Country *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Country(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Country__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Country'.\n  Possible C/C++ prototypes are:\n    FIX::Country()\n    FIX::Country(FIX::COUNTRY const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::UnderlyingLegSecurityIDSource *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingLegSecurityIDSource__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingLegSecurityIDSource'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingLegSecurityIDSource()\n    FIX::UnderlyingLegSecurityIDSource(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlexProductEligibilityIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::FlexProductEligibilityIndicator *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlexProductEligibilityIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_FlexProductEligibilityIndicator__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_FlexProductEligibilityIndicator'.\n  Possible C/C++ prototypes are:\n    FIX::FlexProductEligibilityIndicator()\n    FIX::FlexProductEligibilityIndicator(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AggressorIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::AggressorIndicator *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AggressorIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_AggressorIndicator__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AggressorIndicator'.\n  Possible C/C++ prototypes are:\n    FIX::AggressorIndicator()\n    FIX::AggressorIndicator(FIX::BOOLEAN const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecPriceAdjustment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::ExecPriceAdjustment *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecPriceAdjustment(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_ExecPriceAdjustment__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ExecPriceAdjustment'.\n  Possible C/C++ prototypes are:\n    FIX::ExecPriceAdjustment()\n    FIX::ExecPriceAdjustment(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BusinessRejectReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::BusinessRejectReason *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BusinessRejectReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_BusinessRejectReason__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BusinessRejectReason'.\n  Possible C/C++ prototypes are:\n    FIX::BusinessRejectReason()\n    FIX::BusinessRejectReason(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  FIX::TradeDate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TradeDate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TradeDate'.\n  Possible C/C++ prototypes are:\n    FIX::TradeDate()\n    FIX::TradeDate(FIX::LOCALMKTDATE const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingPutOrCall__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::UnderlyingPutOrCall *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingPutOrCall(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingPutOrCall__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingPutOrCall'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingPutOrCall()\n    FIX::UnderlyingPutOrCall(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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_RelationshipRiskSymbolSfx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelationshipRiskSymbolSfx *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyArg_ParseTuple(args,(char *)":new_RelationshipRiskSymbolSfx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelationshipRiskSymbolSfx *)new FIX::RelationshipRiskSymbolSfx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelationshipRiskSymbolSfx, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_RelationshipRiskSymbolSfx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    return _wrap_new_RelationshipRiskSymbolSfx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_RelationshipRiskSymbolSfx__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RelationshipRiskSymbolSfx'.\n  Possible C/C++ prototypes are:\n    FIX::RelationshipRiskSymbolSfx()\n    FIX::RelationshipRiskSymbolSfx(FIX::STRING const &)\n");
  return NULL;
}


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


SWIGINTERN PyObject *RelationshipRiskSymbolSfx_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RelationshipRiskSymbolSfx, 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingInstrumentPartyRole__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::UnderlyingInstrumentPartyRole *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingInstrumentPartyRole(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_UnderlyingInstrumentPartyRole__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnderlyingInstrumentPartyRole'.\n  Possible C/C++ prototypes are:\n    FIX::UnderlyingInstrumentPartyRole()\n    FIX::UnderlyingInstrumentPartyRole(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativePositionLimit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::DerivativePositionLimit *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativePositionLimit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DerivativePositionLimit__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DerivativePositionLimit'.\n  Possible C/C++ prototypes are:\n    FIX::DerivativePositionLimit()\n    FIX::DerivativePositionLimit(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TierCode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::TierCode *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TierCode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_TierCode__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TierCode'.\n  Possible C/C++ prototypes are:\n    FIX::TierCode()\n    FIX::TierCode(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BookingType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  FIX::BookingType *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BookingType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_BookingType__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BookingType'.\n  Possible C/C++ prototypes are:\n    FIX::BookingType()\n    FIX::BookingType(FIX::INT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StipulationValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  FIX::StipulationValue *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StipulationValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_StipulationValue__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StipulationValue'.\n  Possible C/C++ prototypes are:\n    FIX::StipulationValue()\n    FIX::StipulationValue(FIX::STRING const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlCurrBidFxRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  FIX::SettlCurrBidFxRate *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlCurrBidFxRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SettlCurrBidFxRate__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettlCurrBidFxRate'.\n  Possible C/C++ prototypes are:\n    FIX::SettlCurrBidFxRate()\n    FIX::SettlCurrBidFxRate(FIX::FLOAT const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 BeginString_FIXT11_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BeginString_FIXT11 is read-only.");
  return 1;
}


SWIGINTERN PyObject *BeginString_FIXT11_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BeginString_FIXT11);
  return pyobj;
}


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


SWIGINTERN PyObject *BeginString_FIX50_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BeginString_FIX50);
  return pyobj;
}


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


SWIGINTERN PyObject *BeginString_FIX44_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BeginString_FIX44);
  return pyobj;
}


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


SWIGINTERN PyObject *BeginString_FIX43_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BeginString_FIX43);
  return pyobj;
}


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


SWIGINTERN PyObject *BeginString_FIX42_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BeginString_FIX42);
  return pyobj;
}


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


SWIGINTERN PyObject *BeginString_FIX41_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BeginString_FIX41);
  return pyobj;
}


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


SWIGINTERN PyObject *BeginString_FIX40_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BeginString_FIX40);
  return pyobj;
}


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


SWIGINTERN PyObject *SessionRejectReason_INVALID_TAG_NUMBER_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_INVALID_TAG_NUMBER_TEXT);
  return pyobj;
}


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


SWIGINTERN PyObject *SessionRejectReason_REQUIRED_TAG_MISSING_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_REQUIRED_TAG_MISSING_TEXT);
  return pyobj;
}


SWIGINTERN int 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 *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 SessionRejectReason_UNDEFINED_TAG_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_UNDEFINED_TAG_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SessionRejectReason_UNDEFINED_TAG_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_UNDEFINED_TAG_TEXT);
  return pyobj;
}


SWIGINTERN int 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 *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 SessionRejectReason_VALUE_IS_INCORRECT_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_VALUE_IS_INCORRECT_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SessionRejectReason_VALUE_IS_INCORRECT_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_VALUE_IS_INCORRECT_TEXT);
  return pyobj;
}


SWIGINTERN int 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 *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 SessionRejectReason_DECRYPTION_PROBLEM_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_DECRYPTION_PROBLEM_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SessionRejectReason_DECRYPTION_PROBLEM_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_DECRYPTION_PROBLEM_TEXT);
  return pyobj;
}


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


SWIGINTERN PyObject *SessionRejectReason_SIGNATURE_PROBLEM_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_SIGNATURE_PROBLEM_TEXT);
  return pyobj;
}


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


SWIGINTERN PyObject *SessionRejectReason_COMPID_PROBLEM_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_COMPID_PROBLEM_TEXT);
  return pyobj;
}


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


SWIGINTERN PyObject *SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_TEXT);
  return pyobj;
}


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


SWIGINTERN PyObject *SessionRejectReason_INVALID_MSGTYPE_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_INVALID_MSGTYPE_TEXT);
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 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 *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 BusinessRejectReason_OTHER_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_OTHER_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *BusinessRejectReason_OTHER_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BusinessRejectReason_OTHER_TEXT);
  return pyobj;
}


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


SWIGINTERN PyObject *BusinessRejectReason_UNKNOWN_ID_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BusinessRejectReason_UNKNOWN_ID_TEXT);
  return pyobj;
}


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


SWIGINTERN PyObject *BusinessRejectReason_UNKNOWN_SECURITY_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BusinessRejectReason_UNKNOWN_SECURITY_TEXT);
  return pyobj;
}


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


SWIGINTERN PyObject *BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_TEXT);
  return pyobj;
}


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


SWIGINTERN PyObject *BusinessRejectReason_APPLICATION_NOT_AVAILABLE_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BusinessRejectReason_APPLICATION_NOT_AVAILABLE_TEXT);
  return pyobj;
}


SWIGINTERN int 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 *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 BusinessRejectReason_NOT_AUTHORIZED_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_NOT_AUTHORIZED_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *BusinessRejectReason_NOT_AUTHORIZED_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BusinessRejectReason_NOT_AUTHORIZED_TEXT);
  return pyobj;
}


SWIGINTERN int 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 *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 DeliveryForm_BOOKENTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryForm_BOOKENTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeliveryForm_BOOKENTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryForm_BOOKENTRY));
  return pyobj;
}


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


SWIGINTERN PyObject *DeliveryForm_BEARER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryForm_BEARER));
  return pyobj;
}


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


SWIGINTERN PyObject *DeliveryForm_BOOK_ENTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryForm_BOOK_ENTRY));
  return pyobj;
}


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


SWIGINTERN PyObject *ExecRestatementReason_GTRENEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_GTRENEW));
  return pyobj;
}


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


SWIGINTERN PyObject *ExecRestatementReason_WAREHOUSE_RECAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_WAREHOUSE_RECAP));
  return pyobj;
}


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


SWIGINTERN PyObject *ExecRestatementReason_CANCELEDNOTBEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_CANCELEDNOTBEST));
  return pyobj;
}


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


SWIGINTERN PyObject *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 ExecRestatementReason_CXLTRADINGHALT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_CXLTRADINGHALT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecRestatementReason_CXLTRADINGHALT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_CXLTRADINGHALT));
  return pyobj;
}


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


SWIGINTERN PyObject *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 ExecRestatementReason_GT_CORPORATE_ACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_GT_CORPORATE_ACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecRestatementReason_PEG_REFRESH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_PEG_REFRESH is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecRestatementReason_PEG_REFRESH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_PEG_REFRESH));
  return pyobj;
}


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


SWIGINTERN PyObject *ExecRestatementReason_VERBAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_VERBAL));
  return pyobj;
}


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


SWIGINTERN PyObject *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 ExecRestatementReason_CANCEL_ON_TRADING_HALT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_CANCEL_ON_TRADING_HALT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecRestatementReason_REPX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_REPX is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecRestatementReason_REPX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_REPX));
  return pyobj;
}


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


SWIGINTERN PyObject *ExecRestatementReason_MRKTOPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_MRKTOPTION));
  return pyobj;
}


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


SWIGINTERN PyObject *ExecRestatementReason_VERBAL_CHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_VERBAL_CHANGE));
  return pyobj;
}


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


SWIGINTERN PyObject *ExecRestatementReason_PARTDEC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_PARTDEC));
  return pyobj;
}


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


SWIGINTERN PyObject *ExecRestatementReason_CXLSYSTEMFAILURE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_CXLSYSTEMFAILURE));
  return pyobj;
}


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


SWIGINTERN PyObject *ExecRestatementReason_GTCORPACT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_GTCORPACT));
  return pyobj;
}


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


SWIGINTERN PyObject *ExecRestatementReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_OTHER));
  return pyobj;
}


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


SWIGINTERN PyObject *ExecRestatementReason_BROKER_OPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_BROKER_OPTION));
  return pyobj;
}


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


SWIGINTERN PyObject *ExecRestatementReason_WAREHOUSERECAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_WAREHOUSERECAP));
  return pyobj;
}


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


SWIGINTERN PyObject *ExecRestatementReason_BRKROPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_BRKROPT));
  return pyobj;
}


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


SWIGINTERN PyObject *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 ExecRestatementReason_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecRestatementReason_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_MARKET));
  return pyobj;
}


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


SWIGINTERN PyObject *ExecRestatementReason_GT_RENEWAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_GT_RENEWAL));
  return pyobj;
}


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


SWIGINTERN PyObject *AllocIntermedReqType_PENDING_RELEASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_PENDING_RELEASE));
  return pyobj;
}


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


SWIGINTERN PyObject *AllocIntermedReqType_PENDING_REVERSAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_PENDING_REVERSAL));
  return pyobj;
}


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


SWIGINTERN PyObject *AllocIntermedReqType_ACCOUNTLEVELREJECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_ACCOUNTLEVELREJECT));
  return pyobj;
}


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


SWIGINTERN PyObject *AllocIntermedReqType_PENDINGACCEPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_PENDINGACCEPT));
  return pyobj;
}


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


SWIGINTERN PyObject *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 AllocIntermedReqType_ACCOUNT_LEVEL_REJECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocIntermedReqType_ACCOUNT_LEVEL_REJECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 AllocIntermedReqType_BLOCKLEVELREJECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocIntermedReqType_BLOCKLEVELREJECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocIntermedReqType_BLOCKLEVELREJECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_BLOCKLEVELREJECT));
  return pyobj;
}


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


SWIGINTERN PyObject *AllocIntermedReqType_PENDING_ACCEPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_PENDING_ACCEPT));
  return pyobj;
}


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


SWIGINTERN PyObject *AllocIntermedReqType_PENDINGREVERSAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_PENDINGREVERSAL));
  return pyobj;
}


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


SWIGINTERN PyObject *AllocIntermedReqType_PENDINGRELEASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_PENDINGRELEASE));
  return pyobj;
}


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


SWIGINTERN PyObject *AllocIntermedReqType_ACCEPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_ACCEPT));
  return pyobj;
}


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


SWIGINTERN PyObject *SecurityListTypeSource_GICS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListTypeSource_GICS));
  return pyobj;
}


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


SWIGINTERN PyObject *SecurityListTypeSource_NAICS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListTypeSource_NAICS));
  return pyobj;
}


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


SWIGINTERN PyObject *SecurityListTypeSource_ICB_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListTypeSource_ICB));
  return pyobj;
}


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


SWIGINTERN PyObject *CollInquiryQualifier_PARTIALLY_ASSIGNED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_PARTIALLY_ASSIGNED));
  return pyobj;
}


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


SWIGINTERN PyObject *CollInquiryQualifier_OUTSTANDING_TRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_OUTSTANDING_TRADES));
  return pyobj;
}


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


SWIGINTERN PyObject *CollInquiryQualifier_SUBSTITUTIONELIGIBLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_SUBSTITUTIONELIGIBLE));
  return pyobj;
}


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


SWIGINTERN PyObject *CollInquiryQualifier_TRADE_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_TRADE_DATE));
  return pyobj;
}


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


SWIGINTERN PyObject *CollInquiryQualifier_FULLYASSIGNED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_FULLYASSIGNED));
  return pyobj;
}


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


SWIGINTERN PyObject *CollInquiryQualifier_SUBSTITUTION_ELIGIBLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_SUBSTITUTION_ELIGIBLE));
  return pyobj;
}


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


SWIGINTERN PyObject *CollInquiryQualifier_FULLY_ASSIGNED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_FULLY_ASSIGNED));
  return pyobj;
}


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


SWIGINTERN PyObject *CollInquiryQualifier_NOTASSIGNED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_NOTASSIGNED));
  return pyobj;
}


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


SWIGINTERN PyObject *CollInquiryQualifier_GCINSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_GCINSTRUMENT));
  return pyobj;
}


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


SWIGINTERN PyObject *CollInquiryQualifier_NOT_ASSIGNED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_NOT_ASSIGNED));
  return pyobj;
}


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


SWIGINTERN PyObject *CollInquiryQualifier_COLLATERAL_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_COLLATERAL_INSTRUMENT));
  return pyobj;
}


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


SWIGINTERN PyObject *CollInquiryQualifier_OUTSTANDINGTRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_OUTSTANDINGTRADES));
  return pyobj;
}


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


SWIGINTERN PyObject *CollInquiryQualifier_TRADEDATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_TRADEDATE));
  return pyobj;
}


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


SWIGINTERN PyObject *CollInquiryQualifier_GC_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_GC_INSTRUMENT));
  return pyobj;
}


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


SWIGINTERN PyObject *CollInquiryQualifier_PARTIALLYASSIGNED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_PARTIALLYASSIGNED));
  return pyobj;
}


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


SWIGINTERN PyObject *CollInquiryQualifier_COLLATERALINSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_COLLATERALINSTRUMENT));
  return pyobj;
}


SWIGINTERN int 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 *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 ContingencyType_ONE_TRIGGERS_THE_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContingencyType_ONE_TRIGGERS_THE_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ContingencyType_ONE_CANCELS_THE_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContingencyType_ONE_CANCELS_THE_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 EmailType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EmailType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *EmailType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::EmailType_NEW));
  return pyobj;
}


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


SWIGINTERN PyObject *EmailType_REPLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::EmailType_REPLY));
  return pyobj;
}


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


SWIGINTERN PyObject *EmailType_ADMIN_REPLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::EmailType_ADMIN_REPLY));
  return pyobj;
}


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


SWIGINTERN PyObject *EmailType_ADMINREPLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::EmailType_ADMINREPLY));
  return pyobj;
}


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


SWIGINTERN PyObject *IOIQltyInd_MEDIUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQltyInd_MEDIUM));
  return pyobj;
}


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


SWIGINTERN PyObject *IOIQltyInd_HIGH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQltyInd_HIGH));
  return pyobj;
}


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


SWIGINTERN PyObject *IOIQltyInd_LOW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQltyInd_LOW));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 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 *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 AccountType_ACCOUNTCUSTOMER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AccountType_ACCOUNTCUSTOMER is read-only.");
  return 1;
}


SWIGINTERN PyObject *AccountType_ACCOUNTCUSTOMER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AccountType_ACCOUNTCUSTOMER));
  return pyobj;
}


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


SWIGINTERN PyObject *AccountType_HOUSE_TRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AccountType_HOUSE_TRADER));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 AccountType_FLOOR_TRADER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AccountType_FLOOR_TRADER is read-only.");
  return 1;
}


SWIGINTERN PyObject *AccountType_FLOOR_TRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AccountType_FLOOR_TRADER));
  return pyobj;
}


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


SWIGINTERN PyObject *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 AccountType_HOUSETRADER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AccountType_HOUSETRADER is read-only.");
  return 1;
}


SWIGINTERN PyObject *AccountType_HOUSETRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AccountType_HOUSETRADER));
  return pyobj;
}


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


SWIGINTERN PyObject *AccountType_FLOORTRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AccountType_FLOORTRADER));
  return pyobj;
}


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


SWIGINTERN PyObject *AccountType_ACCOUNTNONCUSTOMERCROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AccountType_ACCOUNTNONCUSTOMERCROSS));
  return pyobj;
}


SWIGINTERN int 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 *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 AccountType_ACCOUNTNONCUSTOMER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AccountType_ACCOUNTNONCUSTOMER is read-only.");
  return 1;
}


SWIGINTERN PyObject *AccountType_ACCOUNTNONCUSTOMER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AccountType_ACCOUNTNONCUSTOMER));
  return pyobj;
}


SWIGINTERN int 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 *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 AccountType_HOUSETRADERCROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AccountType_HOUSETRADERCROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *AccountType_HOUSETRADERCROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AccountType_HOUSETRADERCROSS));
  return pyobj;
}


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


SWIGINTERN PyObject *AccountType_JOINTBOACCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AccountType_JOINTBOACCT));
  return pyobj;
}


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


SWIGINTERN PyObject *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 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 *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 HaltReasonInt_ADDITIONAL_INFORMATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonInt_ADDITIONAL_INFORMATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *HaltReasonInt_ADDITIONAL_INFORMATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::HaltReasonInt_ADDITIONAL_INFORMATION));
  return pyobj;
}


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


SWIGINTERN PyObject *HaltReasonInt_NEWS_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::HaltReasonInt_NEWS_PENDING));
  return pyobj;
}


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


SWIGINTERN PyObject *HaltReasonInt_ORDER_INFLUX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::HaltReasonInt_ORDER_INFLUX));
  return pyobj;
}


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


SWIGINTERN PyObject *HaltReasonInt_NEWS_DISSEMINATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::HaltReasonInt_NEWS_DISSEMINATION));
  return pyobj;
}


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


SWIGINTERN PyObject *HaltReasonInt_EQUIPMENT_CHANGEOVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::HaltReasonInt_EQUIPMENT_CHANGEOVER));
  return pyobj;
}


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


SWIGINTERN PyObject *HaltReasonInt_ORDER_IMBALANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::HaltReasonInt_ORDER_IMBALANCE));
  return pyobj;
}


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


SWIGINTERN PyObject *ClearingFeeIndicator_3RDYEARDELEGATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_3RDYEARDELEGATE);
  return pyobj;
}


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


SWIGINTERN PyObject *ClearingFeeIndicator_FULLASSOCIATEMEMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_FULLASSOCIATEMEMBER);
  return pyobj;
}


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


SWIGINTERN PyObject *ClearingFeeIndicator_106H_AND_106J_FIRMS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_106H_AND_106J_FIRMS);
  return pyobj;
}


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


SWIGINTERN PyObject *ClearingFeeIndicator_4THYEARDELEGATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_4THYEARDELEGATE);
  return pyobj;
}


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


SWIGINTERN PyObject *ClearingFeeIndicator_5THYEARDELEGATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_5THYEARDELEGATE);
  return pyobj;
}


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


SWIGINTERN PyObject *ClearingFeeIndicator_EQUITYCLEARINGMEMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_EQUITYCLEARINGMEMBER);
  return pyobj;
}


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


SWIGINTERN PyObject *ClearingFeeIndicator_GIMIDEMCOMMEMBERSHIP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_GIMIDEMCOMMEMBERSHIP);
  return pyobj;
}


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


SWIGINTERN PyObject *ClearingFeeIndicator_2NDYEARDELEGATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_2NDYEARDELEGATE);
  return pyobj;
}


SWIGINTERN int 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 *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 ClearingFeeIndicator_1STYEARDELEGATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_1STYEARDELEGATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ClearingFeeIndicator_1STYEARDELEGATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_1STYEARDELEGATE);
  return pyobj;
}


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


SWIGINTERN PyObject *ClearingFeeIndicator_106H106J_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_106H106J);
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 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 *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 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 *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 ClearingFeeIndicator_LESSEE_106F_EMPLOYEES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_LESSEE_106F_EMPLOYEES is read-only.");
  return 1;
}


SWIGINTERN PyObject *ClearingFeeIndicator_LESSEE_106F_EMPLOYEES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_LESSEE_106F_EMPLOYEES);
  return pyobj;
}


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


SWIGINTERN PyObject *ClearingFeeIndicator_6THYEARDELEGATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_6THYEARDELEGATE);
  return pyobj;
}


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


SWIGINTERN PyObject *ClearingFeeIndicator_NON_MEMBER_AND_CUSTOMER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_NON_MEMBER_AND_CUSTOMER);
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 ClearingFeeIndicator_CBOE_MEMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_CBOE_MEMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *ClearingFeeIndicator_CBOE_MEMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_CBOE_MEMBER);
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 ClearingFeeIndicator_NONMEMBERCUSTOMER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_NONMEMBERCUSTOMER is read-only.");
  return 1;
}


SWIGINTERN PyObject *ClearingFeeIndicator_NONMEMBERCUSTOMER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_NONMEMBERCUSTOMER);
  return pyobj;
}


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


SWIGINTERN PyObject *ClearingFeeIndicator_LESSEE_AND_106F_EMPLOYEES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_LESSEE_AND_106F_EMPLOYEES);
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 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 *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 ClearingFeeIndicator_CBOEMEMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_CBOEMEMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *ClearingFeeIndicator_CBOEMEMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_CBOEMEMBER);
  return pyobj;
}


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


SWIGINTERN PyObject *ClearingFeeIndicator_LESSEE106F_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_LESSEE106F);
  return pyobj;
}


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


SWIGINTERN PyObject *ClearingFeeIndicator_ALLOTHERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_ALLOTHERS);
  return pyobj;
}


SWIGINTERN int 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 *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 ClearingFeeIndicator_ALL_OTHER_OWNERSHIP_TYPES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_ALL_OTHER_OWNERSHIP_TYPES is read-only.");
  return 1;
}


SWIGINTERN PyObject *ClearingFeeIndicator_ALL_OTHER_OWNERSHIP_TYPES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_ALL_OTHER_OWNERSHIP_TYPES);
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 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 *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 BidType_DISCLOSED_STYLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidType_DISCLOSED_STYLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *BidType_DISCLOSED_STYLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BidType_DISCLOSED_STYLE));
  return pyobj;
}


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


SWIGINTERN PyObject *BidType_NONDISC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BidType_NONDISC));
  return pyobj;
}


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


SWIGINTERN PyObject *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 BidType_DISC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidType_DISC is read-only.");
  return 1;
}


SWIGINTERN PyObject *BidType_DISC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BidType_DISC));
  return pyobj;
}


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


SWIGINTERN PyObject *BidType_DISCLOSED_SYTLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BidType_DISCLOSED_SYTLE));
  return pyobj;
}


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


SWIGINTERN PyObject *BidType_NOBID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BidType_NOBID));
  return pyobj;
}


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


SWIGINTERN PyObject *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 QuotePriceType_PER_SHARE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_PER_SHARE is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuotePriceType_PER_SHARE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_PER_SHARE));
  return pyobj;
}


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


SWIGINTERN PyObject *QuotePriceType_BASISPOINTSRELATIVETOBENCHMARK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_BASISPOINTSRELATIVETOBENCHMARK));
  return pyobj;
}


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


SWIGINTERN PyObject *QuotePriceType_TEDPRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_TEDPRICE));
  return pyobj;
}


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


SWIGINTERN PyObject *QuotePriceType_PERSHARE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_PERSHARE));
  return pyobj;
}


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


SWIGINTERN PyObject *QuotePriceType_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_YIELD));
  return pyobj;
}


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


SWIGINTERN PyObject *QuotePriceType_FIXED_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_FIXED_AMOUNT));
  return pyobj;
}


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


SWIGINTERN PyObject *QuotePriceType_TED_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_TED_YIELD));
  return pyobj;
}


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


SWIGINTERN PyObject *QuotePriceType_PREMIUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_PREMIUM));
  return pyobj;
}


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


SWIGINTERN PyObject *QuotePriceType_FIXEDAMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_FIXEDAMOUNT));
  return pyobj;
}


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


SWIGINTERN PyObject *QuotePriceType_YIELDSPREADSWAPS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_YIELDSPREADSWAPS));
  return pyobj;
}


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


SWIGINTERN PyObject *QuotePriceType_TEDYIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_TEDYIELD));
  return pyobj;
}


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


SWIGINTERN PyObject *QuotePriceType_DISCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_DISCOUNT));
  return pyobj;
}


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


SWIGINTERN PyObject *QuotePriceType_YIELD_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_YIELD_SPREAD));
  return pyobj;
}


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


SWIGINTERN PyObject *QuotePriceType_TED_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_TED_PRICE));
  return pyobj;
}


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


SWIGINTERN PyObject *QuotePriceType_PERCENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_PERCENT));
  return pyobj;
}


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


SWIGINTERN PyObject *QuotePriceType_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_SPREAD));
  return pyobj;
}


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


SWIGINTERN PyObject *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 MultilegPriceMethod_REVERSED_NET_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultilegPriceMethod_REVERSED_NET_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MultilegPriceMethod_MULTIPLIED_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultilegPriceMethod_MULTIPLIED_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MultilegPriceMethod_MULTIPLIED_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MultilegPriceMethod_MULTIPLIED_PRICE));
  return pyobj;
}


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


SWIGINTERN PyObject *MultilegPriceMethod_INDIVIDUAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MultilegPriceMethod_INDIVIDUAL));
  return pyobj;
}


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


SWIGINTERN PyObject *MultilegPriceMethod_YIELD_DIFFERENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MultilegPriceMethod_YIELD_DIFFERENCE));
  return pyobj;
}


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


SWIGINTERN PyObject *MultilegPriceMethod_NET_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MultilegPriceMethod_NET_PRICE));
  return pyobj;
}


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


SWIGINTERN PyObject *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 ListMethod_USER_REQUESTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListMethod_USER_REQUESTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListMethod_USER_REQUESTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListMethod_USER_REQUESTED));
  return pyobj;
}


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


SWIGINTERN PyObject *MDImplicitDelete_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDImplicitDelete_NO));
  return pyobj;
}


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


SWIGINTERN PyObject *MDImplicitDelete_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDImplicitDelete_YES));
  return pyobj;
}


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


SWIGINTERN PyObject *RoutingType_BLOCKLIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RoutingType_BLOCKLIST));
  return pyobj;
}


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


SWIGINTERN PyObject *RoutingType_TARGET_LIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RoutingType_TARGET_LIST));
  return pyobj;
}


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


SWIGINTERN PyObject *RoutingType_TARGET_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RoutingType_TARGET_FIRM));
  return pyobj;
}


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


SWIGINTERN PyObject *RoutingType_TARGETFIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RoutingType_TARGETFIRM));
  return pyobj;
}


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


SWIGINTERN PyObject *RoutingType_TARGETLIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RoutingType_TARGETLIST));
  return pyobj;
}


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


SWIGINTERN PyObject *RoutingType_BLOCK_LIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RoutingType_BLOCK_LIST));
  return pyobj;
}


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


SWIGINTERN PyObject *RoutingType_BLOCK_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RoutingType_BLOCK_FIRM));
  return pyobj;
}


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


SWIGINTERN PyObject *RoutingType_BLOCKFIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RoutingType_BLOCKFIRM));
  return pyobj;
}


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


SWIGINTERN PyObject *BidTradeType_RISKTRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BidTradeType_RISKTRADE));
  return pyobj;
}


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


SWIGINTERN PyObject *BidTradeType_VWAPGUARANTEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BidTradeType_VWAPGUARANTEE));
  return pyobj;
}


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


SWIGINTERN PyObject *BidTradeType_AGENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BidTradeType_AGENCY));
  return pyobj;
}


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


SWIGINTERN PyObject *BidTradeType_GUARANTEEDCLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BidTradeType_GUARANTEEDCLOSE));
  return pyobj;
}


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


SWIGINTERN PyObject *BidTradeType_VWAP_GUARANTEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BidTradeType_VWAP_GUARANTEE));
  return pyobj;
}


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


SWIGINTERN PyObject *BidTradeType_RISK_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BidTradeType_RISK_TRADE));
  return pyobj;
}


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


SWIGINTERN PyObject *BidTradeType_GUARANTEED_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BidTradeType_GUARANTEED_CLOSE));
  return pyobj;
}


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


SWIGINTERN PyObject *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 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 *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 OrdRejReason_DUPLICATEVERBAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_DUPLICATEVERBAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdRejReason_DUPLICATEVERBAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_DUPLICATEVERBAL));
  return pyobj;
}


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


SWIGINTERN PyObject *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 OrdRejReason_EXCHANGE_CLOSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_EXCHANGE_CLOSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdRejReason_EXCHANGE_CLOSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_EXCHANGE_CLOSED));
  return pyobj;
}


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


SWIGINTERN PyObject *OrdRejReason_DUPLICATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_DUPLICATE));
  return pyobj;
}


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


SWIGINTERN PyObject *OrdRejReason_SURVEILLENCE_OPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_SURVEILLENCE_OPTION));
  return pyobj;
}


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


SWIGINTERN PyObject *OrdRejReason_UNKNOWN_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_UNKNOWN_ORDER));
  return pyobj;
}


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


SWIGINTERN PyObject *OrdRejReason_INCORRECTALLOCATEDQUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_INCORRECTALLOCATEDQUANTITY));
  return pyobj;
}


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


SWIGINTERN PyObject *OrdRejReason_TOOLATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_TOOLATE));
  return pyobj;
}


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


SWIGINTERN PyObject *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 OrdRejReason_DUPLICATE_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_DUPLICATE_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdRejReason_DUPLICATE_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_DUPLICATE_ORDER));
  return pyobj;
}


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


SWIGINTERN PyObject *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 OrdRejReason_INCORRECT_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_INCORRECT_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdRejReason_INCORRECT_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_INCORRECT_QUANTITY));
  return pyobj;
}


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


SWIGINTERN PyObject *OrdRejReason_UNKNOWNSYM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_UNKNOWNSYM));
  return pyobj;
}


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


SWIGINTERN PyObject *OrdRejReason_STALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_STALE));
  return pyobj;
}


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


SWIGINTERN PyObject *OrdRejReason_UNKNOWN_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_UNKNOWN_ACCOUNT));
  return pyobj;
}


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


SWIGINTERN PyObject *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 OrdRejReason_BROKEROPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_BROKEROPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdRejReason_BROKEROPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_BROKEROPT));
  return pyobj;
}


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


SWIGINTERN PyObject *OrdRejReason_EXCEEDSLIM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_EXCEEDSLIM));
  return pyobj;
}


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


SWIGINTERN PyObject *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 OrdRejReason_UNKNOWN_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_UNKNOWN_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdRejReason_UNKNOWN_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_UNKNOWN_SYMBOL));
  return pyobj;
}


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


SWIGINTERN PyObject *OrdRejReason_INCORRECTQUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_INCORRECTQUANTITY));
  return pyobj;
}


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


SWIGINTERN PyObject *OrdRejReason_UNKNOWNACCOUNTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_UNKNOWNACCOUNTS));
  return pyobj;
}


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


SWIGINTERN PyObject *OrdRejReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_OTHER));
  return pyobj;
}


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


SWIGINTERN PyObject *OrdRejReason_BROKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_BROKER));
  return pyobj;
}


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


SWIGINTERN PyObject *OrdRejReason_BROKER_OPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_BROKER_OPTION));
  return pyobj;
}


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


SWIGINTERN PyObject *OrdRejReason_SURVEILLENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_SURVEILLENCE));
  return pyobj;
}


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


SWIGINTERN PyObject *OrdRejReason_EXCHCLOSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_EXCHCLOSED));
  return pyobj;
}


SWIGINTERN int 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 *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 OrdRejReason_INVINVID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_INVINVID is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdRejReason_INVINVID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_INVINVID));
  return pyobj;
}


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


SWIGINTERN PyObject *OrdRejReason_UNSUPPORDERCHAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_UNSUPPORDERCHAR));
  return pyobj;
}


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


SWIGINTERN PyObject *OrdRejReason_TRADEALONGREQ_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_TRADEALONGREQ));
  return pyobj;
}


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


SWIGINTERN PyObject *OrdRejReason_UNKNOWN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_UNKNOWN));
  return pyobj;
}


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


SWIGINTERN PyObject *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 OrdRejReason_STALE_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_STALE_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdRejReason_STALE_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_STALE_ORDER));
  return pyobj;
}


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


SWIGINTERN PyObject *MaturityMonthYearIncrementUnits_WEEKS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearIncrementUnits_WEEKS));
  return pyobj;
}


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


SWIGINTERN PyObject *MaturityMonthYearIncrementUnits_MONTHS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearIncrementUnits_MONTHS));
  return pyobj;
}


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


SWIGINTERN PyObject *MaturityMonthYearIncrementUnits_YEARS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearIncrementUnits_YEARS));
  return pyobj;
}


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


SWIGINTERN PyObject *MaturityMonthYearIncrementUnits_DAYS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearIncrementUnits_DAYS));
  return pyobj;
}


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


SWIGINTERN PyObject *DisplayWhen_EXHAUST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DisplayWhen_EXHAUST));
  return pyobj;
}


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


SWIGINTERN PyObject *DisplayWhen_IMMEDIATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DisplayWhen_IMMEDIATE));
  return pyobj;
}


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


SWIGINTERN PyObject *ApplQueueAction_END_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplQueueAction_END_SESSION));
  return pyobj;
}


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


SWIGINTERN PyObject *ApplQueueAction_QUEUEFLUSHED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplQueueAction_QUEUEFLUSHED));
  return pyobj;
}


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


SWIGINTERN PyObject *ApplQueueAction_QUEUE_FLUSHED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplQueueAction_QUEUE_FLUSHED));
  return pyobj;
}


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


SWIGINTERN PyObject *ApplQueueAction_ENDSESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplQueueAction_ENDSESSION));
  return pyobj;
}


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


SWIGINTERN PyObject *ApplQueueAction_OVERLAYLAST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplQueueAction_OVERLAYLAST));
  return pyobj;
}


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


SWIGINTERN PyObject *ApplQueueAction_OVERLAY_LAST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplQueueAction_OVERLAY_LAST));
  return pyobj;
}


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


SWIGINTERN PyObject *ApplQueueAction_NOACTIONTAKEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplQueueAction_NOACTIONTAKEN));
  return pyobj;
}


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


SWIGINTERN PyObject *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 RegistTransType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistTransType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *RegistTransType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RegistTransType_REPLACE));
  return pyobj;
}


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


SWIGINTERN PyObject *RegistTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RegistTransType_NEW));
  return pyobj;
}


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


SWIGINTERN PyObject *RegistTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RegistTransType_CANCEL));
  return pyobj;
}


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


SWIGINTERN PyObject *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 PriceType_FIXEDCABINETTRADEPRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_FIXEDCABINETTRADEPRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PriceType_FIXEDCABINETTRADEPRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_FIXEDCABINETTRADEPRICE));
  return pyobj;
}


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


SWIGINTERN PyObject *PriceType_PER_SHARE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PER_SHARE));
  return pyobj;
}


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


SWIGINTERN PyObject *PriceType_PCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PCT));
  return pyobj;
}


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


SWIGINTERN PyObject *PriceType_VARIABLECABINETTRADEPRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_VARIABLECABINETTRADEPRICE));
  return pyobj;
}


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


SWIGINTERN PyObject *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 PriceType_TEDPRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_TEDPRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PriceType_TEDPRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_TEDPRICE));
  return pyobj;
}


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


SWIGINTERN PyObject *PriceType_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_YIELD));
  return pyobj;
}


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


SWIGINTERN PyObject *PriceType_TED_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_TED_YIELD));
  return pyobj;
}


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


SWIGINTERN PyObject *PriceType_PREMIUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PREMIUM));
  return pyobj;
}


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


SWIGINTERN PyObject *PriceType_FIXED_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_FIXED_AMOUNT));
  return pyobj;
}


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


SWIGINTERN PyObject *PriceType_TEDYIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_TEDYIELD));
  return pyobj;
}


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


SWIGINTERN PyObject *PriceType_DISCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_DISCOUNT));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 PriceType_CPS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_CPS is read-only.");
  return 1;
}


SWIGINTERN PyObject *PriceType_CPS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_CPS));
  return pyobj;
}


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


SWIGINTERN PyObject *PriceType_PERCENTAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PERCENTAGE));
  return pyobj;
}


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


SWIGINTERN PyObject *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 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 *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 PriceType_ABS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_ABS is read-only.");
  return 1;
}


SWIGINTERN PyObject *PriceType_ABS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_ABS));
  return pyobj;
}


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


SWIGINTERN PyObject *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 PriceType_PER_UNIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_PER_UNIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *PriceType_PER_UNIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PER_UNIT));
  return pyobj;
}


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


SWIGINTERN PyObject *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 PriceType_TED_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_TED_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PriceType_TED_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_TED_PRICE));
  return pyobj;
}


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


SWIGINTERN PyObject *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 PriceType_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *PriceType_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_SPREAD));
  return pyobj;
}


SWIGINTERN int 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 *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 SettlObligMode_PRELIMINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlObligMode_PRELIMINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlObligMode_PRELIMINARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlObligMode_PRELIMINARY));
  return pyobj;
}


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


SWIGINTERN PyObject *SettlObligMode_FINAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlObligMode_FINAL));
  return pyobj;
}


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


SWIGINTERN PyObject *SecurityUpdateAction_DELETE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SecurityUpdateAction_DELETE));
  return pyobj;
}


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


SWIGINTERN PyObject *SecurityUpdateAction_ADD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SecurityUpdateAction_ADD));
  return pyobj;
}


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


SWIGINTERN PyObject *SecurityUpdateAction_MODIFY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SecurityUpdateAction_MODIFY));
  return pyobj;
}


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


SWIGINTERN PyObject *NetworkRequestType_STOP_SUBSCRIBING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NetworkRequestType_STOP_SUBSCRIBING));
  return pyobj;
}


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


SWIGINTERN PyObject *NetworkRequestType_LEVELOFDETAIL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NetworkRequestType_LEVELOFDETAIL));
  return pyobj;
}


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


SWIGINTERN PyObject *NetworkRequestType_SUBSCRIBE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NetworkRequestType_SUBSCRIBE));
  return pyobj;
}


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


SWIGINTERN PyObject *NetworkRequestType_SNAPSHOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NetworkRequestType_SNAPSHOT));
  return pyobj;
}


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


SWIGINTERN PyObject *NetworkRequestType_STOPSUBSCRIBING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NetworkRequestType_STOPSUBSCRIBING));
  return pyobj;
}


SWIGINTERN int 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 *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 PartyRole_TRADER_MNEMONIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_TRADER_MNEMONIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRole_TRADER_MNEMONIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_TRADER_MNEMONIC));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_ACCEPTABLE_COUNTERPARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ACCEPTABLE_COUNTERPARTY));
  return pyobj;
}


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


SWIGINTERN PyObject *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 PartyRole_CONTRATRADER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CONTRATRADER is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRole_CONTRATRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CONTRATRADER));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_EXECUTINGFIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXECUTINGFIRM));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_CUSTOMER_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CUSTOMER_ACCOUNT));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_POSITIONACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_POSITIONACCOUNT));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_REPORT_ORIGINATOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_REPORT_ORIGINATOR));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_CONTRAFIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CONTRAFIRM));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_EXECUTION_VENUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXECUTION_VENUE));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_INTERMEDIARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_INTERMEDIARY));
  return pyobj;
}


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


SWIGINTERN PyObject *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 PartyRole_INTRODUCING_BROKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_INTRODUCING_BROKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRole_INTRODUCING_BROKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_INTRODUCING_BROKER));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_FOREIGN_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_FOREIGN_FIRM));
  return pyobj;
}


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


SWIGINTERN PyObject *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 PartyRole_EXECUTINGSYSTEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_EXECUTINGSYSTEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRole_EXECUTINGSYSTEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXECUTINGSYSTEM));
  return pyobj;
}


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


SWIGINTERN PyObject *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 PartyRole_INVESTMENT_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_INVESTMENT_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRole_INVESTMENT_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_INVESTMENT_FIRM));
  return pyobj;
}


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


SWIGINTERN PyObject *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 PartyRole_CONTRA_POSITION_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CONTRA_POSITION_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PartyRole_SYSTEMATIC_INTERNALISER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_SYSTEMATIC_INTERNALISER is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRole_SYSTEMATIC_INTERNALISER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_SYSTEMATIC_INTERNALISER));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_EXCHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXCHANGE));
  return pyobj;
}


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


SWIGINTERN PyObject *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 PartyRole_LOCATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_LOCATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRole_LOCATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_LOCATE));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_CORRESPONDENTCLEARINGORGANIZATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CORRESPONDENTCLEARINGORGANIZATION));
  return pyobj;
}


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


SWIGINTERN PyObject *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 PartyRole_SUB_CUSTODIAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_SUB_CUSTODIAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRole_SUB_CUSTODIAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_SUB_CUSTODIAN));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_ENTERING_UNIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ENTERING_UNIT));
  return pyobj;
}


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


SWIGINTERN PyObject *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 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 *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 PartyRole_SENDER_LOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_SENDER_LOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRole_SENDER_LOCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_SENDER_LOCATION));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_REGULATED_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_REGULATED_MARKET));
  return pyobj;
}


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


SWIGINTERN PyObject *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 PartyRole_SETTLEMENTLOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_SETTLEMENTLOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRole_SETTLEMENTLOCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_SETTLEMENTLOCATION));
  return pyobj;
}


SWIGINTERN int 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 *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 PartyRole_QUOTE_ORIGINATOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_QUOTE_ORIGINATOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRole_QUOTE_ORIGINATOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_QUOTE_ORIGINATOR));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_CLEARING_ORGANIZATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CLEARING_ORGANIZATION));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_SESSION_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_SESSION_ID));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_MARKET_MAKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_MARKET_MAKER));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_INTERESTED_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_INTERESTED_PARTY));
  return pyobj;
}


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


SWIGINTERN PyObject *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 PartyRole_CONTRA_TRADER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CONTRA_TRADER is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRole_CONTRA_TRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CONTRA_TRADER));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_ENTERINGTRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ENTERINGTRADER));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_ENTERING_TRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ENTERING_TRADER));
  return pyobj;
}


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


SWIGINTERN PyObject *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 PartyRole_BENEFICIARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_BENEFICIARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRole_BENEFICIARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_BENEFICIARY));
  return pyobj;
}


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


SWIGINTERN PyObject *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 PartyRole_FORIEGN_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_FORIEGN_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRole_FORIEGN_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_FORIEGN_FIRM));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_SETTLEMENT_LOCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_SETTLEMENT_LOCATION));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_CLEARINGORGANIZATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CLEARINGORGANIZATION));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_EXECUTING_SYSTEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXECUTING_SYSTEM));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_CLEARING_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CLEARING_FIRM));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_PLEDGEE_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_PLEDGEE_ACCOUNT));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_CLIENT_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CLIENT_ID));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_ENTERING_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ENTERING_FIRM));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_ALLOCENTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ALLOCENTITY));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_INVESTOR_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_INVESTOR_ID));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_CLEARINGFIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CLEARINGFIRM));
  return pyobj;
}


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


SWIGINTERN PyObject *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 PartyRole_SUBCUSTODIAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_SUBCUSTODIAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRole_SUBCUSTODIAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_SUBCUSTODIAN));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_BUYER_SELLER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_BUYER_SELLER));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_CLEARING_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CLEARING_ACCOUNT));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_ENTERINGFIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ENTERINGFIRM));
  return pyobj;
}


SWIGINTERN int 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 *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 PartyRole_CORRESPONDENT_CLEARING_ORGANIZATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CORRESPONDENT_CLEARING_ORGANIZATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PartyRole_ACCEPTABLE_SETTLING_COUNTERPARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_ACCEPTABLE_SETTLING_COUNTERPARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PartyRole_CUSTOMERACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CUSTOMERACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRole_CUSTOMERACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CUSTOMERACCOUNT));
  return pyobj;
}


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


SWIGINTERN PyObject *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 PartyRole_INTRODUCINGFIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_INTRODUCINGFIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRole_INTRODUCINGFIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_INTRODUCINGFIRM));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_EXECUTING_UNIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXECUTING_UNIT));
  return pyobj;
}


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


SWIGINTERN PyObject *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 PartyRole_INTERESTEDPARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_INTERESTEDPARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRole_INTERESTEDPARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_INTERESTEDPARTY));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_LOCATION_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_LOCATION_ID));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_ORDERORIGINATOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ORDERORIGINATOR));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_CORRESPONDENT_BROKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CORRESPONDENT_BROKER));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_ASSET_MANAGER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ASSET_MANAGER));
  return pyobj;
}


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


SWIGINTERN PyObject *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 PartyRole_SPONSORINGFIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_SPONSORINGFIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRole_SPONSORINGFIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_SPONSORINGFIRM));
  return pyobj;
}


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


SWIGINTERN PyObject *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 PartyRole_CONTRA_EXCHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CONTRA_EXCHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRole_CONTRA_EXCHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CONTRA_EXCHANGE));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_INVESTORID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_INVESTORID));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_FUNDMANAGER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_FUNDMANAGER));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_REGULATORYBODY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_REGULATORYBODY));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_CONTRA_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CONTRA_FIRM));
  return pyobj;
}


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


SWIGINTERN PyObject *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 PartyRole_LIQUIDITYPROVIDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_LIQUIDITYPROVIDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRole_LIQUIDITYPROVIDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_LIQUIDITYPROVIDER));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_GIVEUPCLEARINGFIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_GIVEUPCLEARINGFIRM));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_CONTRACLEARINGFIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CONTRACLEARINGFIRM));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_CLAIMING_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CLAIMING_ACCOUNT));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_INTRODUCING_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_INTRODUCING_FIRM));
  return pyobj;
}


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


SWIGINTERN PyObject *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 PartyRole_EXECUTINGTRADER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_EXECUTINGTRADER is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRole_EXECUTINGTRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXECUTINGTRADER));
  return pyobj;
}


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


SWIGINTERN PyObject *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 PartyRole_EXECUTING_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_EXECUTING_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRole_EXECUTING_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXECUTING_FIRM));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_AGENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_AGENT));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_LIQUIDITY_PROVIDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_LIQUIDITY_PROVIDER));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_POSITION_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_POSITION_ACCOUNT));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_BROKEROFCREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_BROKEROFCREDIT));
  return pyobj;
}


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


SWIGINTERN PyObject *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 PartyRole_CLIENTID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CLIENTID is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRole_CLIENTID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CLIENTID));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_PLEDGOR_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_PLEDGOR_ACCOUNT));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_REPORTING_INTERMEDIARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_REPORTING_INTERMEDIARY));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_EXECUTING_TRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXECUTING_TRADER));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_CUSTODIAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CUSTODIAN));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_BROKERCLEARINGID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_BROKERCLEARINGID));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_CORRESPONDENTBROKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CORRESPONDENTBROKER));
  return pyobj;
}


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


SWIGINTERN PyObject *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 PartyRole_INITIATINGTRADER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_INITIATINGTRADER is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRole_INITIATINGTRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_INITIATINGTRADER));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_REGULATORY_BODY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_REGULATORY_BODY));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_UNACCEPTABLE_COUNTERPARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_UNACCEPTABLE_COUNTERPARTY));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_CORRESPONDANTCLEARINGFIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CORRESPONDANTCLEARINGFIRM));
  return pyobj;
}


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


SWIGINTERN PyObject *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 PartyRole_BUYERSELLERRECEIVERDELIVERER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_BUYERSELLERRECEIVERDELIVERER is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRole_BUYERSELLERRECEIVERDELIVERER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_BUYERSELLERRECEIVERDELIVERER));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_DESK_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_DESK_ID));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_ALLOCATION_ENTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ALLOCATION_ENTITY));
  return pyobj;
}


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


SWIGINTERN PyObject *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 PartyRole_SPONSORING_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_SPONSORING_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRole_SPONSORING_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_SPONSORING_FIRM));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_LOCATELENDINGFIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_LOCATELENDINGFIRM));
  return pyobj;
}


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


SWIGINTERN PyObject *PartyRole_UNDRCONTRAFIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_UNDRCONTRAFIRM));
  return pyobj;
}


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


SWIGINTERN PyObject *AssignmentMethod_PRO_RATA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AssignmentMethod_PRO_RATA));
  return pyobj;
}


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


SWIGINTERN PyObject *AssignmentMethod_RANDOM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AssignmentMethod_RANDOM));
  return pyobj;
}


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


SWIGINTERN PyObject *AssignmentMethod_PRORATA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AssignmentMethod_PRORATA));
  return pyobj;
}


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


SWIGINTERN PyObject *StrategyParameterType_MONTHYEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_MONTHYEAR));
  return pyobj;
}


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


SWIGINTERN PyObject *StrategyParameterType_TZTIMEONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_TZTIMEONLY));
  return pyobj;
}


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


SWIGINTERN PyObject *StrategyParameterType_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_PRICE));
  return pyobj;
}


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


SWIGINTERN PyObject *StrategyParameterType_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_QTY));
  return pyobj;
}


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


SWIGINTERN PyObject *StrategyParameterType_BOOLEAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_BOOLEAN));
  return pyobj;
}


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


SWIGINTERN PyObject *StrategyParameterType_MULTIPLECHARVALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_MULTIPLECHARVALUE));
  return pyobj;
}


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


SWIGINTERN PyObject *StrategyParameterType_CHAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_CHAR));
  return pyobj;
}


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


SWIGINTERN PyObject *StrategyParameterType_NUMINGROUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_NUMINGROUP));
  return pyobj;
}


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


SWIGINTERN PyObject *StrategyParameterType_TAGNUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_TAGNUM));
  return pyobj;
}


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


SWIGINTERN PyObject *StrategyParameterType_COUNTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_COUNTRY));
  return pyobj;
}


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


SWIGINTERN PyObject *StrategyParameterType_TENOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_TENOR));
  return pyobj;
}


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


SWIGINTERN PyObject *StrategyParameterType_LOCALMKTTIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_LOCALMKTTIME));
  return pyobj;
}


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


SWIGINTERN PyObject *StrategyParameterType_INT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_INT));
  return pyobj;
}


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


SWIGINTERN PyObject *StrategyParameterType_LOCALMKTDATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_LOCALMKTDATE));
  return pyobj;
}


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


SWIGINTERN PyObject *StrategyParameterType_EXCHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_EXCHANGE));
  return pyobj;
}


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


SWIGINTERN PyObject *StrategyParameterType_LANGUAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_LANGUAGE));
  return pyobj;
}


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


SWIGINTERN PyObject *StrategyParameterType_MONTH_YEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_MONTH_YEAR));
  return pyobj;
}


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


SWIGINTERN PyObject *StrategyParameterType_PERCENTAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_PERCENTAGE));
  return pyobj;
}


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


SWIGINTERN PyObject *StrategyParameterType_LENGTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_LENGTH));
  return pyobj;
}


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


SWIGINTERN PyObject *StrategyParameterType_TZTIMESTAMP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_TZTIMESTAMP));
  return pyobj;
}


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


SWIGINTERN PyObject *StrategyParameterType_MULTIPLESTRINGVALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_MULTIPLESTRINGVALUE));
  return pyobj;
}


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


SWIGINTERN PyObject *StrategyParameterType_UTCTIMESTAMP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_UTCTIMESTAMP));
  return pyobj;
}


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


SWIGINTERN PyObject *StrategyParameterType_DATA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_DATA));
  return pyobj;
}


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


SWIGINTERN PyObject *StrategyParameterType_CURRENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_CURRENCY));
  return pyobj;
}


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


SWIGINTERN PyObject *StrategyParameterType_STRING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_STRING));
  return pyobj;
}


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


SWIGINTERN PyObject *StrategyParameterType_AMT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_AMT));
  return pyobj;
}


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


SWIGINTERN PyObject *StrategyParameterType_FLOAT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_FLOAT));
  return pyobj;
}


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


SWIGINTERN PyObject *StrategyParameterType_UTCDATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_UTCDATE));
  return pyobj;
}


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


SWIGINTERN PyObject *StrategyParameterType_UTCTIMEONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_UTCTIMEONLY));
  return pyobj;
}


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


SWIGINTERN PyObject *StrategyParameterType_SEQNUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_SEQNUM));
  return pyobj;
}


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


SWIGINTERN PyObject *StrategyParameterType_UTCDATEONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_UTCDATEONLY));
  return pyobj;
}


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


SWIGINTERN PyObject *StrategyParameterType_PRICEOFFSET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_PRICEOFFSET));
  return pyobj;
}


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


SWIGINTERN PyObject *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 EncryptMethod_PGPDESMD5SEEAPPNOTEONFIXWEBSITE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EncryptMethod_PGPDESMD5SEEAPPNOTEONFIXWEBSITE is read-only.");
  return 1;
}


SWIGINTERN PyObject *EncryptMethod_PGPDESMD5SEEAPPNOTEONFIXWEBSITE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_PGPDESMD5SEEAPPNOTEONFIXWEBSITE));
  return pyobj;
}


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


SWIGINTERN PyObject *EncryptMethod_PKCS_DES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_PKCS_DES));
  return pyobj;
}


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


SWIGINTERN PyObject *EncryptMethod_NONEOTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_NONEOTHER));
  return pyobj;
}


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


SWIGINTERN PyObject *EncryptMethod_PKCSDESPROPRIETARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_PKCSDESPROPRIETARY));
  return pyobj;
}


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


SWIGINTERN PyObject *EncryptMethod_PGPDESDEFUNCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_PGPDESDEFUNCT));
  return pyobj;
}


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


SWIGINTERN PyObject *EncryptMethod_PEMDESMD5SEEAPPNOTEONFIXWEBSITENAFORFIXMLNOTUSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_PEMDESMD5SEEAPPNOTEONFIXWEBSITENAFORFIXMLNOTUSED));
  return pyobj;
}


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


SWIGINTERN PyObject *EncryptMethod_PKCS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_PKCS));
  return pyobj;
}


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


SWIGINTERN PyObject *EncryptMethod_PGP_DES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_PGP_DES));
  return pyobj;
}


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


SWIGINTERN PyObject *EncryptMethod_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_NONE));
  return pyobj;
}


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


SWIGINTERN PyObject *EncryptMethod_DES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_DES));
  return pyobj;
}


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


SWIGINTERN PyObject *EncryptMethod_PKCSPROPRIETARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_PKCSPROPRIETARY));
  return pyobj;
}


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


SWIGINTERN PyObject *EncryptMethod_NONE_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_NONE_OTHER));
  return pyobj;
}


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


SWIGINTERN PyObject *EncryptMethod_DESECBMODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_DESECBMODE));
  return pyobj;
}


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


SWIGINTERN PyObject *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 PosAmtType_ACCRUED_COUPON_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_ACCRUED_COUPON_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosAmtType_ACCRUED_COUPON_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_ACCRUED_COUPON_AMOUNT);
  return pyobj;
}


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


SWIGINTERN PyObject *PosAmtType_PREMIUM_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_PREMIUM_AMOUNT);
  return pyobj;
}


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


SWIGINTERN PyObject *PosAmtType_STARTOFDAYMARKTOMARKETAMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_STARTOFDAYMARKTOMARKETAMOUNT);
  return pyobj;
}


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


SWIGINTERN PyObject *PosAmtType_INCREMENTALMARKTOMARKETAMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_INCREMENTALMARKTOMARKETAMOUNT);
  return pyobj;
}


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


SWIGINTERN PyObject *PosAmtType_CASHAMOUNTCORPORATEEVENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_CASHAMOUNTCORPORATEEVENT);
  return pyobj;
}


SWIGINTERN int 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 *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 PosAmtType_TOTAL_BANKED_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_TOTAL_BANKED_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosAmtType_TOTAL_BANKED_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_TOTAL_BANKED_AMOUNT);
  return pyobj;
}


SWIGINTERN int 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 *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 PosAmtType_SETTLEMENT_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_SETTLEMENT_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosAmtType_SETTLEMENT_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_SETTLEMENT_VALUE);
  return pyobj;
}


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


SWIGINTERN PyObject *PosAmtType_VALUEADJUSTEDAMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_VALUEADJUSTEDAMOUNT);
  return pyobj;
}


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


SWIGINTERN PyObject *PosAmtType_CASH_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_CASH_AMOUNT);
  return pyobj;
}


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


SWIGINTERN PyObject *PosAmtType_PREMIUMAMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_PREMIUMAMOUNT);
  return pyobj;
}


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


SWIGINTERN PyObject *PosAmtType_INITIAL_TRADE_COUPON_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_INITIAL_TRADE_COUPON_AMOUNT);
  return pyobj;
}


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


SWIGINTERN PyObject *PosAmtType_INCREMENTAL_ACCRUED_COUPON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_INCREMENTAL_ACCRUED_COUPON);
  return pyobj;
}


SWIGINTERN int 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 *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 PosAmtType_VALUE_ADJUSTED_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_VALUE_ADJUSTED_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosAmtType_VALUE_ADJUSTED_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_VALUE_ADJUSTED_AMOUNT);
  return pyobj;
}


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


SWIGINTERN PyObject *PosAmtType_CASHRESIDUALAMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_CASHRESIDUALAMOUNT);
  return pyobj;
}


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


SWIGINTERN PyObject *PosAmtType_COLLATERALIZED_MARK_TO_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_COLLATERALIZED_MARK_TO_MARKET);
  return pyobj;
}


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


SWIGINTERN PyObject *PosAmtType_CASH_RESIDUAL_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_CASH_RESIDUAL_AMOUNT);
  return pyobj;
}


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


SWIGINTERN PyObject *PosAmtType_COMPENSATION_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_COMPENSATION_AMOUNT);
  return pyobj;
}


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


SWIGINTERN PyObject *PosAmtType_TRADE_VARIATION_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_TRADE_VARIATION_AMOUNT);
  return pyobj;
}


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


SWIGINTERN PyObject *PosAmtType_TRADEVARIATIONAMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_TRADEVARIATIONAMOUNT);
  return pyobj;
}


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


SWIGINTERN PyObject *PosAmtType_FINALMARKTOMARKETAMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_FINALMARKTOMARKETAMOUNT);
  return pyobj;
}


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


SWIGINTERN PyObject *PosAmtType_COUPON_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_COUPON_AMOUNT);
  return pyobj;
}


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


SWIGINTERN PyObject *PosAmtType_TOTAL_COLLATERALIZED_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_TOTAL_COLLATERALIZED_AMOUNT);
  return pyobj;
}


SWIGINTERN int 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 *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 ResetSeqNumFlag_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ResetSeqNumFlag_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *ResetSeqNumFlag_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ResetSeqNumFlag_NO));
  return pyobj;
}


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


SWIGINTERN PyObject *ResetSeqNumFlag_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ResetSeqNumFlag_YES));
  return pyobj;
}


SWIGINTERN int 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 *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 CollInquiryResult_NOCOLLATERALFOUNDFORTHEORDERSPECIFIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryResult_NOCOLLATERALFOUNDFORTHEORDERSPECIFIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollInquiryResult_NOCOLLATERALFOUNDFORTHEORDERSPECIFIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_NOCOLLATERALFOUNDFORTHEORDERSPECIFIED));
  return pyobj;
}


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


SWIGINTERN PyObject *CollInquiryResult_NOCOLLATERALFOUNDFORTHETRADESPECIFIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_NOCOLLATERALFOUNDFORTHETRADESPECIFIED));
  return pyobj;
}


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


SWIGINTERN PyObject *CollInquiryResult_INVALIDORUNKNOWNINSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_INVALIDORUNKNOWNINSTRUMENT));
  return pyobj;
}


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


SWIGINTERN PyObject *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 CollInquiryResult_INVALIDORUNKNOWNCOLLATERALTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryResult_INVALIDORUNKNOWNCOLLATERALTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollInquiryResult_INVALIDORUNKNOWNCOLLATERALTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_INVALIDORUNKNOWNCOLLATERALTYPE));
  return pyobj;
}


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


SWIGINTERN PyObject *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 CollInquiryResult_INVALIDTRANSPORTTYPEREQUESTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryResult_INVALIDTRANSPORTTYPEREQUESTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollInquiryResult_INVALIDTRANSPORTTYPEREQUESTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_INVALIDTRANSPORTTYPEREQUESTED));
  return pyobj;
}


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


SWIGINTERN PyObject *CollInquiryResult_INVALIDPARTIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_INVALIDPARTIES));
  return pyobj;
}


SWIGINTERN int 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 *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 CollInquiryResult_INVALIDDESTINATIONREQUESTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryResult_INVALIDDESTINATIONREQUESTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollInquiryResult_INVALIDDESTINATIONREQUESTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_INVALIDDESTINATIONREQUESTED));
  return pyobj;
}


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


SWIGINTERN PyObject *CollInquiryResult_SUCCESSFUL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_SUCCESSFUL));
  return pyobj;
}


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


SWIGINTERN PyObject *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 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 *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 CollInquiryResult_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryResult_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollInquiryResult_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_OTHER));
  return pyobj;
}


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


SWIGINTERN PyObject *CollInquiryResult_UNAUTHORIZEDFORCOLLATERALINQUIRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_UNAUTHORIZEDFORCOLLATERALINQUIRY));
  return pyobj;
}


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


SWIGINTERN PyObject *CollInquiryResult_COLLATERALINQUIRYTYPENOTSUPPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_COLLATERALINQUIRYTYPENOTSUPPORTED));
  return pyobj;
}


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


SWIGINTERN PyObject *CollInquiryResult_INVALID_PARTIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_INVALID_PARTIES));
  return pyobj;
}


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


SWIGINTERN PyObject *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 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 *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 CollAsgnRespType_DECLINED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRespType_DECLINED is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollAsgnRespType_DECLINED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRespType_DECLINED));
  return pyobj;
}


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


SWIGINTERN PyObject *CollAsgnRespType_RECEIVED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRespType_RECEIVED));
  return pyobj;
}


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


SWIGINTERN PyObject *CollAsgnRespType_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRespType_REJECTED));
  return pyobj;
}


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


SWIGINTERN PyObject *CollAsgnRespType_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRespType_ACCEPTED));
  return pyobj;
}


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


SWIGINTERN PyObject *UnsolicitedIndicator_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::UnsolicitedIndicator_NO));
  return pyobj;
}


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


SWIGINTERN PyObject *UnsolicitedIndicator_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::UnsolicitedIndicator_YES));
  return pyobj;
}


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


SWIGINTERN PyObject *QuoteEntryRejectReason_UNKNWNSYM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_UNKNWNSYM));
  return pyobj;
}


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


SWIGINTERN PyObject *QuoteEntryRejectReason_EXCHCLSD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_EXCHCLSD));
  return pyobj;
}


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


SWIGINTERN PyObject *QuoteEntryRejectReason_EXHCNAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_EXHCNAGE));
  return pyobj;
}


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


SWIGINTERN PyObject *QuoteEntryRejectReason_DUPORD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_DUPORD));
  return pyobj;
}


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


SWIGINTERN PyObject *QuoteEntryRejectReason_INVALID_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_INVALID_PRICE));
  return pyobj;
}


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


SWIGINTERN PyObject *QuoteEntryRejectReason_TOOLATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_TOOLATE));
  return pyobj;
}


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


SWIGINTERN PyObject *QuoteEntryRejectReason_INVBIDASK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_INVBIDASK));
  return pyobj;
}


SWIGINTERN int 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 *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 QuoteEntryRejectReason_TOO_LATE_TO_ENTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryRejectReason_TOO_LATE_TO_ENTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 QuoteEntryRejectReason_QUOTE_EXCEEDS_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryRejectReason_QUOTE_EXCEEDS_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 QuoteEntryRejectReason_ORDEXCLIM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryRejectReason_ORDEXCLIM is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteEntryRejectReason_ORDEXCLIM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_ORDEXCLIM));
  return pyobj;
}


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


SWIGINTERN PyObject *QuoteEntryRejectReason_UNKNORD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_UNKNORD));
  return pyobj;
}


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


SWIGINTERN PyObject *QuoteEntryRejectReason_INVPX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_INVPX));
  return pyobj;
}


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


SWIGINTERN PyObject *QuoteEntryRejectReason_EXCHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_EXCHANGE));
  return pyobj;
}


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


SWIGINTERN PyObject *QuoteEntryRejectReason_UNKNOWN_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_UNKNOWN_SYMBOL));
  return pyobj;
}


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


SWIGINTERN PyObject *QuoteEntryRejectReason_NOTAUTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_NOTAUTH));
  return pyobj;
}


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


SWIGINTERN PyObject *QuoteEntryRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_OTHER));
  return pyobj;
}


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


SWIGINTERN PyObject *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 QuoteEntryRejectReason_UNKNOWN_QUOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryRejectReason_UNKNOWN_QUOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteEntryRejectReason_UNKNOWN_QUOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_UNKNOWN_QUOTE));
  return pyobj;
}


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


SWIGINTERN PyObject *QuoteEntryRejectReason_DUPLICATE_QUOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_DUPLICATE_QUOTE));
  return pyobj;
}


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


SWIGINTERN PyObject *OrderCapacity_PROPRIETARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_PROPRIETARY));
  return pyobj;
}


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


SWIGINTERN PyObject *OrderCapacity_RISKLESS_PRINCIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_RISKLESS_PRINCIPAL));
  return pyobj;
}


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


SWIGINTERN PyObject *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 OrderCapacity_PRINCIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCapacity_PRINCIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderCapacity_PRINCIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_PRINCIPAL));
  return pyobj;
}


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


SWIGINTERN PyObject *OrderCapacity_AGENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_AGENCY));
  return pyobj;
}


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


SWIGINTERN PyObject *OrderCapacity_INDIVIDUAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_INDIVIDUAL));
  return pyobj;
}


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


SWIGINTERN PyObject *OrderCapacity_AGENTOTHERMEMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_AGENTOTHERMEMBER));
  return pyobj;
}


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


SWIGINTERN PyObject *OrderCapacity_RISKLESSPRINCIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_RISKLESSPRINCIPAL));
  return pyobj;
}


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


SWIGINTERN PyObject *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 QuoteAckStatus_CANCELED_ALL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteAckStatus_CANCELED_ALL is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteAckStatus_CANCELED_ALL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteAckStatus_CANCELED_ALL));
  return pyobj;
}


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


SWIGINTERN PyObject *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 QuoteAckStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteAckStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteAckStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteAckStatus_REJECTED));
  return pyobj;
}


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


SWIGINTERN PyObject *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 QuoteAckStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteAckStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteAckStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteAckStatus_ACCEPTED));
  return pyobj;
}


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


SWIGINTERN PyObject *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 UserRequestType_CHANGEPASSWORDFORUSER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserRequestType_CHANGEPASSWORDFORUSER is read-only.");
  return 1;
}


SWIGINTERN PyObject *UserRequestType_CHANGEPASSWORDFORUSER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserRequestType_CHANGEPASSWORDFORUSER));
  return pyobj;
}


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


SWIGINTERN PyObject *UserRequestType_LOGOFFUSER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserRequestType_LOGOFFUSER));
  return pyobj;
}


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


SWIGINTERN PyObject *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 UserRequestType_REQUEST_INDIVIDUAL_USER_STATUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserRequestType_REQUEST_INDIVIDUAL_USER_STATUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 UserRequestType_REQUESTINDIVIDUALUSERSTATUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserRequestType_REQUESTINDIVIDUALUSERSTATUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *UserRequestType_REQUESTINDIVIDUALUSERSTATUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserRequestType_REQUESTINDIVIDUALUSERSTATUS));
  return pyobj;
}


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


SWIGINTERN PyObject *UserRequestType_LOGONUSER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserRequestType_LOGONUSER));
  return pyobj;
}


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


SWIGINTERN PyObject *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 TradeReportTransType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportTransType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeReportTransType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportTransType_REPLACE));
  return pyobj;
}


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


SWIGINTERN PyObject *TradeReportTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportTransType_NEW));
  return pyobj;
}


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


SWIGINTERN PyObject *TradeReportTransType_REVERSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportTransType_REVERSE));
  return pyobj;
}


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


SWIGINTERN PyObject *TradeReportTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportTransType_CANCEL));
  return pyobj;
}


SWIGINTERN int 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 *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 TradeReportTransType_RELEASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportTransType_RELEASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeReportTransType_RELEASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportTransType_RELEASE));
  return pyobj;
}


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


SWIGINTERN PyObject *AdvSide_CROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AdvSide_CROSS));
  return pyobj;
}


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


SWIGINTERN PyObject *AdvSide_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AdvSide_TRADE));
  return pyobj;
}


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


SWIGINTERN PyObject *AdvSide_BUY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AdvSide_BUY));
  return pyobj;
}


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


SWIGINTERN PyObject *AdvSide_SELL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AdvSide_SELL));
  return pyobj;
}


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


SWIGINTERN PyObject *CoveredOrUncovered_COVERED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CoveredOrUncovered_COVERED));
  return pyobj;
}


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


SWIGINTERN PyObject *CoveredOrUncovered_UNCOVERED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CoveredOrUncovered_UNCOVERED));
  return pyobj;
}


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


SWIGINTERN PyObject *AcctIDSource_TFMGSPTA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_TFMGSPTA));
  return pyobj;
}


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


SWIGINTERN PyObject *AcctIDSource_TFM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_TFM));
  return pyobj;
}


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


SWIGINTERN PyObject *AcctIDSource_DTCCCODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_DTCCCODE));
  return pyobj;
}


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


SWIGINTERN PyObject *AcctIDSource_SIDCODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_SIDCODE));
  return pyobj;
}


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


SWIGINTERN PyObject *AcctIDSource_OMGEOALERTID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_OMGEOALERTID));
  return pyobj;
}


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


SWIGINTERN PyObject *AcctIDSource_BIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_BIC));
  return pyobj;
}


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


SWIGINTERN PyObject *AcctIDSource_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_OTHER));
  return pyobj;
}


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


SWIGINTERN PyObject *AcctIDSource_OMGEO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_OMGEO));
  return pyobj;
}


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


SWIGINTERN PyObject *AcctIDSource_SID_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_SID_CODE));
  return pyobj;
}


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


SWIGINTERN PyObject *AcctIDSource_DTCC_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_DTCC_CODE));
  return pyobj;
}


SWIGINTERN int 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 *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 TradeRequestType_ALL_TRADES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestType_ALL_TRADES is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeRequestType_ALL_TRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestType_ALL_TRADES));
  return pyobj;
}


SWIGINTERN int 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 *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 TradeRequestType_UNREPORTEDTRADES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestType_UNREPORTEDTRADES is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeRequestType_UNREPORTEDTRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestType_UNREPORTEDTRADES));
  return pyobj;
}


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


SWIGINTERN PyObject *TradeRequestType_ALLTRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestType_ALLTRADES));
  return pyobj;
}


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


SWIGINTERN PyObject *TradeRequestType_ADVISORIESMATCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestType_ADVISORIESMATCH));
  return pyobj;
}


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


SWIGINTERN PyObject *TradeRequestType_MATCHEDTRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestType_MATCHEDTRADES));
  return pyobj;
}


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


SWIGINTERN PyObject *TradeRequestType_UNMATCHEDTRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestType_UNMATCHEDTRADES));
  return pyobj;
}


SWIGINTERN int 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 *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 TradeRequestType_ADVISORIES_THAT_MATCH_CRITERIA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestType_ADVISORIES_THAT_MATCH_CRITERIA is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TradSesStatus_PRECLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesStatus_PRECLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradSesStatus_PRECLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_PRECLOSE));
  return pyobj;
}


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


SWIGINTERN PyObject *TradSesStatus_HALTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_HALTED));
  return pyobj;
}


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


SWIGINTERN PyObject *TradSesStatus_REQREJ_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_REQREJ));
  return pyobj;
}


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


SWIGINTERN PyObject *TradSesStatus_REQUEST_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_REQUEST_REJECTED));
  return pyobj;
}


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


SWIGINTERN PyObject *TradSesStatus_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_OPEN));
  return pyobj;
}


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


SWIGINTERN PyObject *TradSesStatus_PREOPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_PREOPEN));
  return pyobj;
}


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


SWIGINTERN PyObject *TradSesStatus_PRE_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_PRE_OPEN));
  return pyobj;
}


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


SWIGINTERN PyObject *TradSesStatus_UNKNOWN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_UNKNOWN));
  return pyobj;
}


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


SWIGINTERN PyObject *TradSesStatus_PRE_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_PRE_CLOSE));
  return pyobj;
}


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


SWIGINTERN PyObject *TradSesStatus_CLOSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_CLOSED));
  return pyobj;
}


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


SWIGINTERN PyObject *PegPriceType_LAST_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegPriceType_LAST_PEG));
  return pyobj;
}


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


SWIGINTERN PyObject *PegPriceType_PRIMARY_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegPriceType_PRIMARY_PEG));
  return pyobj;
}


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


SWIGINTERN PyObject *PegPriceType_OPENING_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegPriceType_OPENING_PEG));
  return pyobj;
}


SWIGINTERN int 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 *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 PegPriceType_TRAILING_STOP_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegPriceType_TRAILING_STOP_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PegPriceType_PEG_TO_LIMIT_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegPriceType_PEG_TO_LIMIT_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PegPriceType_MID_PRICE_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegPriceType_MID_PRICE_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PegPriceType_MARKET_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegPriceType_MARKET_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *PegPriceType_MARKET_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegPriceType_MARKET_PEG));
  return pyobj;
}


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


SWIGINTERN PyObject *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 StreamAsgnRejReason_NO_AVAILABLE_STREAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnRejReason_NO_AVAILABLE_STREAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 StreamAsgnRejReason_EXCEEDS_MAXIMUM_SIZE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnRejReason_EXCEEDS_MAXIMUM_SIZE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 StreamAsgnRejReason_UNKNOWN_CLIENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnRejReason_UNKNOWN_CLIENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *StreamAsgnRejReason_UNKNOWN_CLIENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamAsgnRejReason_UNKNOWN_CLIENT));
  return pyobj;
}


SWIGINTERN int 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 *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 StreamAsgnRejReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnRejReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *StreamAsgnRejReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamAsgnRejReason_OTHER));
  return pyobj;
}


SWIGINTERN int 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 *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 ValuationMethod_PREMIUM_STYLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ValuationMethod_PREMIUM_STYLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ValuationMethod_PREMIUM_STYLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ValuationMethod_PREMIUM_STYLE);
  return pyobj;
}


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


SWIGINTERN PyObject *ValuationMethod_CDS_IN_DELIVERY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ValuationMethod_CDS_IN_DELIVERY);
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 TriggerType_SPECIFIED_TRADING_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerType_SPECIFIED_TRADING_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TriggerType_NEXT_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerType_NEXT_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *TriggerType_NEXT_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerType_NEXT_AUCTION));
  return pyobj;
}


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


SWIGINTERN PyObject *TriggerType_PRICE_MOVEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerType_PRICE_MOVEMENT));
  return pyobj;
}


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


SWIGINTERN PyObject *TriggerType_PARTIAL_EXECUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerType_PARTIAL_EXECUTION));
  return pyobj;
}


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


SWIGINTERN PyObject *PriceProtectionScope_LOCAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PriceProtectionScope_LOCAL));
  return pyobj;
}


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


SWIGINTERN PyObject *PriceProtectionScope_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PriceProtectionScope_NONE));
  return pyobj;
}


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


SWIGINTERN PyObject *PriceProtectionScope_GLOBAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PriceProtectionScope_GLOBAL));
  return pyobj;
}


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


SWIGINTERN PyObject *PriceProtectionScope_NATIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PriceProtectionScope_NATIONAL));
  return pyobj;
}


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


SWIGINTERN PyObject *TradeReportRejectReason_SUCCESSFULDEFAULT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_SUCCESSFULDEFAULT));
  return pyobj;
}


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


SWIGINTERN PyObject *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 TradeReportRejectReason_SUCCESSFUL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportRejectReason_SUCCESSFUL is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeReportRejectReason_SUCCESSFUL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_SUCCESSFUL));
  return pyobj;
}


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


SWIGINTERN PyObject *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 TradeReportRejectReason_UNKNOWN_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportRejectReason_UNKNOWN_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeReportRejectReason_UNKNOWN_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_UNKNOWN_INSTRUMENT));
  return pyobj;
}


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


SWIGINTERN PyObject *TradeReportRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_OTHER));
  return pyobj;
}


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


SWIGINTERN PyObject *TradeReportRejectReason_INVALIDTRADETYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_INVALIDTRADETYPE));
  return pyobj;
}


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


SWIGINTERN PyObject *TradeReportRejectReason_UNKNOWNINSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_UNKNOWNINSTRUMENT));
  return pyobj;
}


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


SWIGINTERN PyObject *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 TradeReportRejectReason_UNAUTHORIZEDTOREPORTTRADES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportRejectReason_UNAUTHORIZEDTOREPORTTRADES is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeReportRejectReason_UNAUTHORIZEDTOREPORTTRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_UNAUTHORIZEDTOREPORTTRADES));
  return pyobj;
}


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


SWIGINTERN PyObject *TradeReportRejectReason_INVALIDPARTYINFORMATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_INVALIDPARTYINFORMATION));
  return pyobj;
}


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


SWIGINTERN PyObject *SecurityListType_NEWSPAPER_LIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListType_NEWSPAPER_LIST));
  return pyobj;
}


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


SWIGINTERN PyObject *SecurityListType_TRADING_LIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListType_TRADING_LIST));
  return pyobj;
}


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


SWIGINTERN PyObject *SecurityListType_INDUSTRY_CLASSIFICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListType_INDUSTRY_CLASSIFICATION));
  return pyobj;
}


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


SWIGINTERN PyObject *SecurityListType_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListType_MARKET));
  return pyobj;
}


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


SWIGINTERN PyObject *QuoteRejectReason_QUOTE_LOCKED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_QUOTE_LOCKED));
  return pyobj;
}


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


SWIGINTERN PyObject *QuoteRejectReason_UNKNSYM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_UNKNSYM));
  return pyobj;
}


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


SWIGINTERN PyObject *QuoteRejectReason_EXCHCLSD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_EXCHCLSD));
  return pyobj;
}


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


SWIGINTERN PyObject *QuoteRejectReason_DUPORD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_DUPORD));
  return pyobj;
}


SWIGINTERN int 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 *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 QuoteRejectReason_INVALID_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_INVALID_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRejectReason_INVALID_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_INVALID_PRICE));
  return pyobj;
}


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


SWIGINTERN PyObject *QuoteRejectReason_TOOLATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_TOOLATE));
  return pyobj;
}


SWIGINTERN int 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 *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 QuoteRejectReason_TOO_LATE_TO_ENTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_TOO_LATE_TO_ENTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 QuoteRejectReason_UNKNORD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_UNKNORD is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRejectReason_UNKNORD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_UNKNORD));
  return pyobj;
}


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


SWIGINTERN PyObject *QuoteRejectReason_INVPX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_INVPX));
  return pyobj;
}


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


SWIGINTERN PyObject *QuoteRejectReason_EXCHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_EXCHANGE));
  return pyobj;
}


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


SWIGINTERN PyObject *QuoteRejectReason_INVSPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_INVSPREAD));
  return pyobj;
}


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


SWIGINTERN PyObject *QuoteRejectReason_UNKNOWN_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_UNKNOWN_SYMBOL));
  return pyobj;
}


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


SWIGINTERN PyObject *QuoteRejectReason_NOTAUTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_NOTAUTH));
  return pyobj;
}


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


SWIGINTERN PyObject *QuoteRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_OTHER));
  return pyobj;
}


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


SWIGINTERN PyObject *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 QuoteRejectReason_UNKNOWN_QUOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_UNKNOWN_QUOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRejectReason_UNKNOWN_QUOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_UNKNOWN_QUOTE));
  return pyobj;
}


SWIGINTERN int 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 *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 QuoteRejectReason_ORDEXLIM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_ORDEXLIM is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRejectReason_ORDEXLIM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_ORDEXLIM));
  return pyobj;
}


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


SWIGINTERN PyObject *QuoteRejectReason_DUPLICATE_QUOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_DUPLICATE_QUOTE));
  return pyobj;
}


SWIGINTERN int 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 *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 QuoteRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PossResend_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PossResend_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *PossResend_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PossResend_NO));
  return pyobj;
}


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


SWIGINTERN PyObject *PossResend_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PossResend_YES));
  return pyobj;
}


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


SWIGINTERN PyObject *QuantityType_SHARES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuantityType_SHARES));
  return pyobj;
}


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


SWIGINTERN PyObject *QuantityType_CURRENTFACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuantityType_CURRENTFACE));
  return pyobj;
}


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


SWIGINTERN PyObject *QuantityType_PAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuantityType_PAR));
  return pyobj;
}


SWIGINTERN int QuantityType_BONDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuantityType_BONDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuantityType_BONDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuantityType_BONDS));
  return pyobj;
}


SWIGINTERN int QuantityType_ORIGINALFACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuantityType_ORIGINALFACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuantityType_ORIGINALFACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuantityType_ORIGINALFACE));
  return pyobj;
}


SWIGINTERN int QuantityType_CONTRACTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuantityType_CONTRACTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuantityType_CONTRACTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuantityType_CONTRACTS));
  return pyobj;
}


SWIGINTERN int QuantityType_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuantityType_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuantityType_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuantityType_OTHER));
  return pyobj;
}


SWIGINTERN int QuantityType_CURRENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuantityType_CURRENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuantityType_CURRENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuantityType_CURRENCY));
  return pyobj;
}


SWIGINTERN int 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 *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 ComplexEventPriceBoundaryMethod_EQUAL_TO_COMPLEXEVENTPRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPriceBoundaryMethod_EQUAL_TO_COMPLEXEVENTPRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ComplexEventPriceBoundaryMethod_LESS_THAN_COMPLEXEVENTPRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPriceBoundaryMethod_LESS_THAN_COMPLEXEVENTPRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ComplexEventPriceBoundaryMethod_GREATER_THAN_COMPLEXEVENTPRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPriceBoundaryMethod_GREATER_THAN_COMPLEXEVENTPRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 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 *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 ImpliedMarketIndicator_NOT_IMPLIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ImpliedMarketIndicator_NOT_IMPLIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *ImpliedMarketIndicator_NOT_IMPLIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ImpliedMarketIndicator_NOT_IMPLIED));
  return pyobj;
}


SWIGINTERN int ImpliedMarketIndicator_IMPLIED_OUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ImpliedMarketIndicator_IMPLIED_OUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ImpliedMarketIndicator_IMPLIED_OUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ImpliedMarketIndicator_IMPLIED_OUT));
  return pyobj;
}


SWIGINTERN int ImpliedMarketIndicator_IMPLIED_IN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ImpliedMarketIndicator_IMPLIED_IN is read-only.");
  return 1;
}


SWIGINTERN PyObject *ImpliedMarketIndicator_IMPLIED_IN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ImpliedMarketIndicator_IMPLIED_IN));
  return pyobj;
}


SWIGINTERN int QuoteRequestType_AUTOMATIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestType_AUTOMATIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRequestType_AUTOMATIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestType_AUTOMATIC));
  return pyobj;
}


SWIGINTERN int QuoteRequestType_MAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestType_MAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRequestType_MAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestType_MAN));
  return pyobj;
}


SWIGINTERN int QuoteRequestType_AUTO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestType_AUTO is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRequestType_AUTO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestType_AUTO));
  return pyobj;
}


SWIGINTERN int QuoteRequestType_MANUAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestType_MANUAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRequestType_MANUAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestType_MANUAL));
  return pyobj;
}


SWIGINTERN int SecurityRequestResult_INSTRUMENTUNAVAILABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestResult_INSTRUMENTUNAVAILABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityRequestResult_INSTRUMENTUNAVAILABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestResult_INSTRUMENTUNAVAILABLE));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 SecurityRequestResult_INSTRUMENT_DATA_TEMPORARILY_UNAVAILABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestResult_INSTRUMENT_DATA_TEMPORARILY_UNAVAILABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SecurityRequestResult_VALID_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestResult_VALID_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityRequestResult_VALID_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestResult_VALID_REQUEST));
  return pyobj;
}


SWIGINTERN int SecurityRequestResult_VALIDREQ_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestResult_VALIDREQ is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityRequestResult_VALIDREQ_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestResult_VALIDREQ));
  return pyobj;
}


SWIGINTERN int SecurityRequestResult_NOINSTRUMENTSFOUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestResult_NOINSTRUMENTSFOUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityRequestResult_NOINSTRUMENTSFOUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestResult_NOINSTRUMENTSFOUND));
  return pyobj;
}


SWIGINTERN int SecurityRequestResult_INVALID_OR_UNSUPPORTED_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestResult_INVALID_OR_UNSUPPORTED_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SecurityRequestResult_NOTAUTHORIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestResult_NOTAUTHORIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityRequestResult_NOTAUTHORIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestResult_NOTAUTHORIZED));
  return pyobj;
}


SWIGINTERN int SecurityRequestResult_NOTSUPPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestResult_NOTSUPPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityRequestResult_NOTSUPPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestResult_NOTSUPPORTED));
  return pyobj;
}


SWIGINTERN int SecurityRequestResult_INVALIDREQ_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestResult_INVALIDREQ is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityRequestResult_INVALIDREQ_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestResult_INVALIDREQ));
  return pyobj;
}


SWIGINTERN int 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 *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 OrderRestrictions_ISSUER_HOLDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_ISSUER_HOLDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderRestrictions_ISSUER_HOLDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_ISSUER_HOLDING));
  return pyobj;
}


SWIGINTERN int OrderRestrictions_NON_INDEXARBITRAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_NON_INDEXARBITRAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderRestrictions_NON_INDEXARBITRAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_NON_INDEXARBITRAGE));
  return pyobj;
}


SWIGINTERN int OrderRestrictions_EXMRKTPART_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_EXMRKTPART is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderRestrictions_EXMRKTPART_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_EXMRKTPART));
  return pyobj;
}


SWIGINTERN int 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 *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 OrderRestrictions_NON_ALGORITHMIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_NON_ALGORITHMIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderRestrictions_NON_ALGORITHMIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_NON_ALGORITHMIC));
  return pyobj;
}


SWIGINTERN int 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 *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 OrderRestrictions_NON_INDEX_ARBITRAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_NON_INDEX_ARBITRAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 OrderRestrictions_PROGRAM_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_PROGRAM_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderRestrictions_PROGRAM_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_PROGRAM_TRADE));
  return pyobj;
}


SWIGINTERN int OrderRestrictions_ISSUE_PRICE_STABILIZATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_ISSUE_PRICE_STABILIZATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 OrderRestrictions_INDEXARBITRAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_INDEXARBITRAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderRestrictions_INDEXARBITRAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_INDEXARBITRAGE));
  return pyobj;
}


SWIGINTERN int OrderRestrictions_ACTMMDERIV_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_ACTMMDERIV is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderRestrictions_ACTMMDERIV_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_ACTMMDERIV));
  return pyobj;
}


SWIGINTERN int OrderRestrictions_FORENTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_FORENTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderRestrictions_FORENTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_FORENTITY));
  return pyobj;
}


SWIGINTERN int OrderRestrictions_CROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_CROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderRestrictions_CROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_CROSS));
  return pyobj;
}


SWIGINTERN int OrderRestrictions_PROGRAMTRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_PROGRAMTRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderRestrictions_PROGRAMTRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_PROGRAMTRADE));
  return pyobj;
}


SWIGINTERN int OrderRestrictions_RISKARB_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_RISKARB is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderRestrictions_RISKARB_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_RISKARB));
  return pyobj;
}


SWIGINTERN int 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 *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 OrderRestrictions_FOREIGN_ENTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_FOREIGN_ENTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderRestrictions_FOREIGN_ENTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_FOREIGN_ENTITY));
  return pyobj;
}


SWIGINTERN int OrderRestrictions_COMPETINGMARKETMAKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_COMPETINGMARKETMAKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderRestrictions_COMPETINGMARKETMAKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_COMPETINGMARKETMAKER));
  return pyobj;
}


SWIGINTERN int OrderRestrictions_EXINTMRKTLINK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_EXINTMRKTLINK is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderRestrictions_EXINTMRKTLINK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_EXINTMRKTLINK));
  return pyobj;
}


SWIGINTERN int OrderRestrictions_INDEX_ARBITRAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_INDEX_ARBITRAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderRestrictions_INDEX_ARBITRAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_INDEX_ARBITRAGE));
  return pyobj;
}


SWIGINTERN int OrderRestrictions_EXTERNAL_MARKET_PARTICIPANT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_EXTERNAL_MARKET_PARTICIPANT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 OrderRestrictions_ALGORITHMIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_ALGORITHMIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderRestrictions_ALGORITHMIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_ALGORITHMIC));
  return pyobj;
}


SWIGINTERN int OrderRestrictions_ACTMM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_ACTMM is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderRestrictions_ACTMM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_ACTMM));
  return pyobj;
}


SWIGINTERN int 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 *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 OrderRestrictions_RISKLESS_ARBITRAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_RISKLESS_ARBITRAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderRestrictions_RISKLESS_ARBITRAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_RISKLESS_ARBITRAGE));
  return pyobj;
}


SWIGINTERN int OrderRestrictions_COMPETING_MARKET_MAKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_COMPETING_MARKET_MAKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ListExecInstType_WAIT_FOR_EXECUT_INSTRUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListExecInstType_WAIT_FOR_EXECUT_INSTRUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 ListExecInstType_IMMED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListExecInstType_IMMED is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListExecInstType_IMMED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_IMMED));
  return pyobj;
}


SWIGINTERN int ListExecInstType_WAIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListExecInstType_WAIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListExecInstType_WAIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_WAIT));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 ListExecInstType_IMMEDIATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListExecInstType_IMMEDIATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListExecInstType_IMMEDIATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_IMMEDIATE));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 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 *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 ListExecInstType_EXCHCIVBUYTOP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListExecInstType_EXCHCIVBUYTOP is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListExecInstType_EXCHCIVBUYTOP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_EXCHCIVBUYTOP));
  return pyobj;
}


SWIGINTERN int ListExecInstType_EXCHCIVBUYWD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListExecInstType_EXCHCIVBUYWD is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListExecInstType_EXCHCIVBUYWD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_EXCHCIVBUYWD));
  return pyobj;
}


SWIGINTERN int ListExecInstType_EXCHCIVSELL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListExecInstType_EXCHCIVSELL is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListExecInstType_EXCHCIVSELL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_EXCHCIVSELL));
  return pyobj;
}


SWIGINTERN int ListExecInstType_WAIT_FOR_EXECUTE_INSTRUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListExecInstType_WAIT_FOR_EXECUTE_INSTRUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 DistribPaymentMethod_FED_WIRE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_FED_WIRE is read-only.");
  return 1;
}


SWIGINTERN PyObject *DistribPaymentMethod_FED_WIRE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_FED_WIRE));
  return pyobj;
}


SWIGINTERN int DistribPaymentMethod_ACH_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_ACH_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *DistribPaymentMethod_ACH_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_ACH_CREDIT));
  return pyobj;
}


SWIGINTERN int DistribPaymentMethod_EUROCLEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_EUROCLEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *DistribPaymentMethod_EUROCLEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_EUROCLEAR));
  return pyobj;
}


SWIGINTERN int DistribPaymentMethod_TELEGRAPHICTRANSFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_TELEGRAPHICTRANSFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *DistribPaymentMethod_TELEGRAPHICTRANSFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_TELEGRAPHICTRANSFER));
  return pyobj;
}


SWIGINTERN int DistribPaymentMethod_ACHCREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_ACHCREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *DistribPaymentMethod_ACHCREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_ACHCREDIT));
  return pyobj;
}


SWIGINTERN int DistribPaymentMethod_TELEGRAPHIC_TRANSFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_TELEGRAPHIC_TRANSFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *DistribPaymentMethod_TELEGRAPHIC_TRANSFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_TELEGRAPHIC_TRANSFER));
  return pyobj;
}


SWIGINTERN int DistribPaymentMethod_FEDWIRE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_FEDWIRE is read-only.");
  return 1;
}


SWIGINTERN PyObject *DistribPaymentMethod_FEDWIRE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_FEDWIRE));
  return pyobj;
}


SWIGINTERN int DistribPaymentMethod_CHEQUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_CHEQUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *DistribPaymentMethod_CHEQUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_CHEQUE));
  return pyobj;
}


SWIGINTERN int DistribPaymentMethod_DIRECT_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_DIRECT_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *DistribPaymentMethod_DIRECT_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_DIRECT_CREDIT));
  return pyobj;
}


SWIGINTERN int DistribPaymentMethod_CREST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_CREST is read-only.");
  return 1;
}


SWIGINTERN PyObject *DistribPaymentMethod_CREST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_CREST));
  return pyobj;
}


SWIGINTERN int DistribPaymentMethod_BPAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_BPAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *DistribPaymentMethod_BPAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_BPAY));
  return pyobj;
}


SWIGINTERN int DistribPaymentMethod_CLEARSTREAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_CLEARSTREAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *DistribPaymentMethod_CLEARSTREAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_CLEARSTREAM));
  return pyobj;
}


SWIGINTERN int DistribPaymentMethod_DIRECTCREDITBECSBACS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_DIRECTCREDITBECSBACS is read-only.");
  return 1;
}


SWIGINTERN PyObject *DistribPaymentMethod_DIRECTCREDITBECSBACS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_DIRECTCREDITBECSBACS));
  return pyobj;
}


SWIGINTERN int DistribPaymentMethod_HIGHVALUECLEARINGSYSTEMHVACS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_HIGHVALUECLEARINGSYSTEMHVACS is read-only.");
  return 1;
}


SWIGINTERN PyObject *DistribPaymentMethod_HIGHVALUECLEARINGSYSTEMHVACS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_HIGHVALUECLEARINGSYSTEMHVACS));
  return pyobj;
}


SWIGINTERN int DistribPaymentMethod_NSCC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_NSCC is read-only.");
  return 1;
}


SWIGINTERN PyObject *DistribPaymentMethod_NSCC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_NSCC));
  return pyobj;
}


SWIGINTERN int 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 *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 DistribPaymentMethod_REINVESTINFUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_REINVESTINFUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *DistribPaymentMethod_REINVESTINFUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_REINVESTINFUND));
  return pyobj;
}


SWIGINTERN int DistribPaymentMethod_REINVEST_IN_FUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_REINVEST_IN_FUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 OrderHandlingInstSource_NASD_OATS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderHandlingInstSource_NASD_OATS is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderHandlingInstSource_NASD_OATS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderHandlingInstSource_NASD_OATS));
  return pyobj;
}


SWIGINTERN int AffirmStatus_CONFIRMREJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AffirmStatus_CONFIRMREJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *AffirmStatus_CONFIRMREJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AffirmStatus_CONFIRMREJECTED));
  return pyobj;
}


SWIGINTERN int 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 *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 AffirmStatus_AFFIRMED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AffirmStatus_AFFIRMED is read-only.");
  return 1;
}


SWIGINTERN PyObject *AffirmStatus_AFFIRMED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AffirmStatus_AFFIRMED));
  return pyobj;
}


SWIGINTERN int AffirmStatus_RECEIVED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AffirmStatus_RECEIVED is read-only.");
  return 1;
}


SWIGINTERN PyObject *AffirmStatus_RECEIVED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AffirmStatus_RECEIVED));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 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 *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 OrigCustOrderCapacity_ALL_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrigCustOrderCapacity_ALL_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrigCustOrderCapacity_ALL_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrigCustOrderCapacity_ALL_OTHER));
  return pyobj;
}


SWIGINTERN int AllocMethod_GUARANTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocMethod_GUARANTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocMethod_GUARANTOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocMethod_GUARANTOR));
  return pyobj;
}


SWIGINTERN int AllocMethod_AUTOMATIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocMethod_AUTOMATIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocMethod_AUTOMATIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocMethod_AUTOMATIC));
  return pyobj;
}


SWIGINTERN int AllocMethod_MANUAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocMethod_MANUAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocMethod_MANUAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocMethod_MANUAL));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 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 *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 MassCancelResponse_CXLORDERSSECURITYTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CXLORDERSSECURITYTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassCancelResponse_CXLORDERSSECURITYTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CXLORDERSSECURITYTYPE));
  return pyobj;
}


SWIGINTERN int MassCancelResponse_CXLORDERSUNDERLYINGSECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CXLORDERSUNDERLYINGSECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassCancelResponse_CXLORDERSUNDERLYINGSECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CXLORDERSUNDERLYINGSECURITY));
  return pyobj;
}


SWIGINTERN int MassCancelResponse_CXLORDERSTRDSESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CXLORDERSTRDSESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassCancelResponse_CXLORDERSTRDSESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CXLORDERSTRDSESSION));
  return pyobj;
}


SWIGINTERN int MassCancelResponse_CXLALLORDERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CXLALLORDERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassCancelResponse_CXLALLORDERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CXLALLORDERS));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 MassCancelResponse_CXLREQREJ_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CXLREQREJ is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassCancelResponse_CXLREQREJ_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CXLREQREJ));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 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 *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 MassCancelResponse_CXLORDERSSECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CXLORDERSSECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassCancelResponse_CXLORDERSSECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CXLORDERSSECURITY));
  return pyobj;
}


SWIGINTERN int MassCancelResponse_CXLORDERSPRODUCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CXLORDERSPRODUCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassCancelResponse_CXLORDERSPRODUCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CXLORDERSPRODUCT));
  return pyobj;
}


SWIGINTERN int MassCancelResponse_CANCEL_ALL_ORDERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CANCEL_ALL_ORDERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MassCancelResponse_CANCEL_REQUEST_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CANCEL_REQUEST_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 MassCancelResponse_CXLORDERSCFICODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CXLORDERSCFICODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassCancelResponse_CXLORDERSCFICODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CXLORDERSCFICODE));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 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 *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 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 *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 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 *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 SymbolSfx_EUCPLUMPSUMINTEREST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SymbolSfx_EUCPLUMPSUMINTEREST is read-only.");
  return 1;
}


SWIGINTERN PyObject *SymbolSfx_EUCPLUMPSUMINTEREST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SymbolSfx_EUCPLUMPSUMINTEREST);
  return pyobj;
}


SWIGINTERN int SymbolSfx_WHENISSUED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SymbolSfx_WHENISSUED is read-only.");
  return 1;
}


SWIGINTERN PyObject *SymbolSfx_WHENISSUED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SymbolSfx_WHENISSUED);
  return pyobj;
}


SWIGINTERN int 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 *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 ExDestinationIDSource_PROPRIETARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExDestinationIDSource_PROPRIETARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExDestinationIDSource_PROPRIETARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExDestinationIDSource_PROPRIETARY));
  return pyobj;
}


SWIGINTERN int 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 *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 ExDestinationIDSource_BIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExDestinationIDSource_BIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExDestinationIDSource_BIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExDestinationIDSource_BIC));
  return pyobj;
}


SWIGINTERN int ExDestinationIDSource_MIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExDestinationIDSource_MIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExDestinationIDSource_MIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExDestinationIDSource_MIC));
  return pyobj;
}


SWIGINTERN int ExDestinationIDSource_ISO_COUNTRY_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExDestinationIDSource_ISO_COUNTRY_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SecurityListRequestType_ALLSECURITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListRequestType_ALLSECURITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityListRequestType_ALLSECURITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListRequestType_ALLSECURITIES));
  return pyobj;
}


SWIGINTERN int 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 *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 SecurityListRequestType_SECURITYTYPECFICODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListRequestType_SECURITYTYPECFICODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityListRequestType_SECURITYTYPECFICODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListRequestType_SECURITYTYPECFICODE));
  return pyobj;
}


SWIGINTERN int SecurityListRequestType_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListRequestType_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityListRequestType_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListRequestType_SYMBOL));
  return pyobj;
}


SWIGINTERN int SecurityListRequestType_SECURITYTYPE_AND_OR_CFICODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListRequestType_SECURITYTYPE_AND_OR_CFICODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SecurityListRequestType_TRADINGSESSIONID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListRequestType_TRADINGSESSIONID is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityListRequestType_TRADINGSESSIONID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListRequestType_TRADINGSESSIONID));
  return pyobj;
}


SWIGINTERN int SecurityListRequestType_ALL_SECURITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListRequestType_ALL_SECURITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityListRequestType_ALL_SECURITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListRequestType_ALL_SECURITIES));
  return pyobj;
}


SWIGINTERN int SecurityListRequestType_PRODUCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListRequestType_PRODUCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityListRequestType_PRODUCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListRequestType_PRODUCT));
  return pyobj;
}


SWIGINTERN int CollAsgnReason_FORWARDCOLLATERALDEMAND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_FORWARDCOLLATERALDEMAND is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollAsgnReason_FORWARDCOLLATERALDEMAND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_FORWARDCOLLATERALDEMAND));
  return pyobj;
}


SWIGINTERN int CollAsgnReason_ADVERSETAXEVENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_ADVERSETAXEVENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollAsgnReason_ADVERSETAXEVENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_ADVERSETAXEVENT));
  return pyobj;
}


SWIGINTERN int CollAsgnReason_MARGINDEFICIENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_MARGINDEFICIENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollAsgnReason_MARGINDEFICIENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_MARGINDEFICIENCY));
  return pyobj;
}


SWIGINTERN int CollAsgnReason_TIME_WARNING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_TIME_WARNING is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollAsgnReason_TIME_WARNING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_TIME_WARNING));
  return pyobj;
}


SWIGINTERN int CollAsgnReason_TIMEWARNING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_TIMEWARNING is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollAsgnReason_TIMEWARNING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_TIMEWARNING));
  return pyobj;
}


SWIGINTERN int CollAsgnReason_ADVERSE_TAX_EVENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_ADVERSE_TAX_EVENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 CollAsgnReason_MARGINEXCESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_MARGINEXCESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollAsgnReason_MARGINEXCESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_MARGINEXCESS));
  return pyobj;
}


SWIGINTERN int CollAsgnReason_MARGIN_DEFICIENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_MARGIN_DEFICIENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollAsgnReason_MARGIN_DEFICIENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_MARGIN_DEFICIENCY));
  return pyobj;
}


SWIGINTERN int CollAsgnReason_SCHEDULED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_SCHEDULED is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollAsgnReason_SCHEDULED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_SCHEDULED));
  return pyobj;
}


SWIGINTERN int CollAsgnReason_INITIAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_INITIAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollAsgnReason_INITIAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_INITIAL));
  return pyobj;
}


SWIGINTERN int CollAsgnReason_FORWARD_COLLATERAL_DEMAND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_FORWARD_COLLATERAL_DEMAND is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 CollAsgnReason_EVENTOFDEFAULT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_EVENTOFDEFAULT is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollAsgnReason_EVENTOFDEFAULT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_EVENTOFDEFAULT));
  return pyobj;
}


SWIGINTERN int CollAsgnReason_MARGIN_EXCESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_MARGIN_EXCESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollAsgnReason_MARGIN_EXCESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_MARGIN_EXCESS));
  return pyobj;
}


SWIGINTERN int CollAsgnReason_EVENT_OF_DEFAULT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_EVENT_OF_DEFAULT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SettlPriceType_FINAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlPriceType_FINAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlPriceType_FINAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlPriceType_FINAL));
  return pyobj;
}


SWIGINTERN int SettlPriceType_THEORETICAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlPriceType_THEORETICAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlPriceType_THEORETICAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlPriceType_THEORETICAL));
  return pyobj;
}


SWIGINTERN int DealingCapacity_RISKLESS_PRINCIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DealingCapacity_RISKLESS_PRINCIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *DealingCapacity_RISKLESS_PRINCIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DealingCapacity_RISKLESS_PRINCIPAL));
  return pyobj;
}


SWIGINTERN int DealingCapacity_PRINCIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DealingCapacity_PRINCIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *DealingCapacity_PRINCIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DealingCapacity_PRINCIPAL));
  return pyobj;
}


SWIGINTERN int DealingCapacity_AGENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DealingCapacity_AGENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *DealingCapacity_AGENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DealingCapacity_AGENT));
  return pyobj;
}


SWIGINTERN int RateSourceType_SECONDARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RateSourceType_SECONDARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *RateSourceType_SECONDARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RateSourceType_SECONDARY));
  return pyobj;
}


SWIGINTERN int RateSourceType_PRIMARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RateSourceType_PRIMARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *RateSourceType_PRIMARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RateSourceType_PRIMARY));
  return pyobj;
}


SWIGINTERN int AggregatedBook_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AggregatedBook_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *AggregatedBook_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AggregatedBook_NO));
  return pyobj;
}


SWIGINTERN int AggregatedBook_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AggregatedBook_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *AggregatedBook_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AggregatedBook_YES));
  return pyobj;
}


SWIGINTERN int PosQtyStatus_SUBMITTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosQtyStatus_SUBMITTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosQtyStatus_SUBMITTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosQtyStatus_SUBMITTED));
  return pyobj;
}


SWIGINTERN int PosQtyStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosQtyStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosQtyStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosQtyStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int PosQtyStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosQtyStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosQtyStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosQtyStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int MsgType_TradingSessionStatusRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_TradingSessionStatusRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_TradingSessionStatusRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TradingSessionStatusRequest);
  return pyobj;
}


SWIGINTERN int MsgType_ListStatus_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_ListStatus is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_ListStatus_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ListStatus);
  return pyobj;
}


SWIGINTERN int MsgType_Email_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_Email is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_Email_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_Email);
  return pyobj;
}


SWIGINTERN int MsgType_ListExecute_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_ListExecute is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_ListExecute_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ListExecute);
  return pyobj;
}


SWIGINTERN int MsgType_Confirmation_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_Confirmation is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_Confirmation_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_Confirmation);
  return pyobj;
}


SWIGINTERN int MsgType_NewOrderMultileg_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_NewOrderMultileg is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_NewOrderMultileg_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_NewOrderMultileg);
  return pyobj;
}


SWIGINTERN int MsgType_IndicationofInterest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_IndicationofInterest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_IndicationofInterest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_IndicationofInterest);
  return pyobj;
}


SWIGINTERN int MsgType_MarketDataIncrementalRefresh_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_MarketDataIncrementalRefresh is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_MarketDataIncrementalRefresh_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MarketDataIncrementalRefresh);
  return pyobj;
}


SWIGINTERN int MsgType_TradeCaptureReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_TradeCaptureReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_TradeCaptureReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TradeCaptureReport);
  return pyobj;
}


SWIGINTERN int MsgType_RequestForPositionsAck_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_RequestForPositionsAck is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_RequestForPositionsAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_RequestForPositionsAck);
  return pyobj;
}


SWIGINTERN int MsgType_StreamAssignmentRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_StreamAssignmentRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_StreamAssignmentRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_StreamAssignmentRequest);
  return pyobj;
}


SWIGINTERN int MsgType_SecurityListRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_SecurityListRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_SecurityListRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SecurityListRequest);
  return pyobj;
}


SWIGINTERN int MsgType_CollateralReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_CollateralReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_CollateralReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_CollateralReport);
  return pyobj;
}


SWIGINTERN int MsgType_PositionMaintenanceReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_PositionMaintenanceReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_PositionMaintenanceReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PositionMaintenanceReport);
  return pyobj;
}


SWIGINTERN int MsgType_PositionReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_PositionReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_PositionReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PositionReport);
  return pyobj;
}


SWIGINTERN int MsgType_StreamAssignmentReportACK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_StreamAssignmentReportACK is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_StreamAssignmentReportACK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_StreamAssignmentReportACK);
  return pyobj;
}


SWIGINTERN int MsgType_UserRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_UserRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_UserRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_UserRequest);
  return pyobj;
}


SWIGINTERN int MsgType_PositionMaintenanceRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_PositionMaintenanceRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_PositionMaintenanceRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PositionMaintenanceRequest);
  return pyobj;
}


SWIGINTERN int MsgType_NetworkCounterpartySystemStatusResponse_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_NetworkCounterpartySystemStatusResponse is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_NetworkCounterpartySystemStatusResponse_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_NetworkCounterpartySystemStatusResponse);
  return pyobj;
}


SWIGINTERN int MsgType_NewOrderCross_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_NewOrderCross is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_NewOrderCross_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_NewOrderCross);
  return pyobj;
}


SWIGINTERN int MsgType_AdjustedPositionReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_AdjustedPositionReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_AdjustedPositionReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_AdjustedPositionReport);
  return pyobj;
}


SWIGINTERN int MsgType_Logon_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_Logon is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_Logon_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_Logon);
  return pyobj;
}


SWIGINTERN int MsgType_IOI_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_IOI is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_IOI_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_IOI);
  return pyobj;
}


SWIGINTERN int MsgType_ListStrikePrice_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_ListStrikePrice is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_ListStrikePrice_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ListStrikePrice);
  return pyobj;
}


SWIGINTERN int MsgType_BidRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_BidRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_BidRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_BidRequest);
  return pyobj;
}


SWIGINTERN int MsgType_TradingSessionStatus_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_TradingSessionStatus is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_TradingSessionStatus_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TradingSessionStatus);
  return pyobj;
}


SWIGINTERN int MsgType_RegistrationInstructionsResponse_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_RegistrationInstructionsResponse is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_RegistrationInstructionsResponse_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_RegistrationInstructionsResponse);
  return pyobj;
}


SWIGINTERN int MsgType_Advertisement_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_Advertisement is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_Advertisement_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_Advertisement);
  return pyobj;
}


SWIGINTERN int MsgType_MassQuote_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_MassQuote is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_MassQuote_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MassQuote);
  return pyobj;
}


SWIGINTERN int MsgType_Logout_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_Logout is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_Logout_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_Logout);
  return pyobj;
}


SWIGINTERN int MsgType_AllocationReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_AllocationReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_AllocationReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_AllocationReport);
  return pyobj;
}


SWIGINTERN int MsgType_SecurityDefinitionUpdateReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_SecurityDefinitionUpdateReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_SecurityDefinitionUpdateReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SecurityDefinitionUpdateReport);
  return pyobj;
}


SWIGINTERN int MsgType_ListStatusRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_ListStatusRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_ListStatusRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ListStatusRequest);
  return pyobj;
}


SWIGINTERN int MsgType_BusinessMessageReject_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_BusinessMessageReject is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_BusinessMessageReject_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_BusinessMessageReject);
  return pyobj;
}


SWIGINTERN int MsgType_ConfirmationAck_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_ConfirmationAck is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_ConfirmationAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ConfirmationAck);
  return pyobj;
}


SWIGINTERN int MsgType_TestRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_TestRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_TestRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TestRequest);
  return pyobj;
}


SWIGINTERN int MsgType_SecurityList_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_SecurityList is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_SecurityList_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SecurityList);
  return pyobj;
}


SWIGINTERN int MsgType_ListCancelRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_ListCancelRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_ListCancelRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ListCancelRequest);
  return pyobj;
}


SWIGINTERN int MsgType_News_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_News is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_News_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_News);
  return pyobj;
}


SWIGINTERN int MsgType_TradingSessionListUpdateReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_TradingSessionListUpdateReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_TradingSessionListUpdateReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TradingSessionListUpdateReport);
  return pyobj;
}


SWIGINTERN int MsgType_Heartbeat_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_Heartbeat is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_Heartbeat_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_Heartbeat);
  return pyobj;
}


SWIGINTERN int MsgType_QuoteAcknowledgement_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_QuoteAcknowledgement is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_QuoteAcknowledgement_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_QuoteAcknowledgement);
  return pyobj;
}


SWIGINTERN int MsgType_AllocationReportAck_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_AllocationReportAck is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_AllocationReportAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_AllocationReportAck);
  return pyobj;
}


SWIGINTERN int MsgType_ConfirmationRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_ConfirmationRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_ConfirmationRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ConfirmationRequest);
  return pyobj;
}


SWIGINTERN int MsgType_OrderMassActionReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_OrderMassActionReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_OrderMassActionReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_OrderMassActionReport);
  return pyobj;
}


SWIGINTERN int MsgType_CollateralInquiry_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_CollateralInquiry is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_CollateralInquiry_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_CollateralInquiry);
  return pyobj;
}


SWIGINTERN int MsgType_SecurityTypeRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_SecurityTypeRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_SecurityTypeRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SecurityTypeRequest);
  return pyobj;
}


SWIGINTERN int MsgType_NewOrderList_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_NewOrderList is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_NewOrderList_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_NewOrderList);
  return pyobj;
}


SWIGINTERN int MsgType_ExecutionAcknowledgement_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_ExecutionAcknowledgement is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_ExecutionAcknowledgement_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ExecutionAcknowledgement);
  return pyobj;
}


SWIGINTERN int MsgType_TradingSessionListRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_TradingSessionListRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_TradingSessionListRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TradingSessionListRequest);
  return pyobj;
}


SWIGINTERN int MsgType_SecurityTypes_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_SecurityTypes is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_SecurityTypes_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SecurityTypes);
  return pyobj;
}


SWIGINTERN int MsgType_MarketDefinition_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_MarketDefinition is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_MarketDefinition_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MarketDefinition);
  return pyobj;
}


SWIGINTERN int MsgType_SequenceReset_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_SequenceReset is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_SequenceReset_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SequenceReset);
  return pyobj;
}


SWIGINTERN int MsgType_CollateralResponse_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_CollateralResponse is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_CollateralResponse_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_CollateralResponse);
  return pyobj;
}


SWIGINTERN int MsgType_MassQuoteAcknowledgement_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_MassQuoteAcknowledgement is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_MassQuoteAcknowledgement_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MassQuoteAcknowledgement);
  return pyobj;
}


SWIGINTERN int MsgType_QuoteResponse_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_QuoteResponse is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_QuoteResponse_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_QuoteResponse);
  return pyobj;
}


SWIGINTERN int MsgType_QuoteStatusRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_QuoteStatusRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_QuoteStatusRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_QuoteStatusRequest);
  return pyobj;
}


SWIGINTERN int MsgType_QuoteCancel_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_QuoteCancel is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_QuoteCancel_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_QuoteCancel);
  return pyobj;
}


SWIGINTERN int MsgType_ContraryIntentionReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_ContraryIntentionReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_ContraryIntentionReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ContraryIntentionReport);
  return pyobj;
}


SWIGINTERN int MsgType_PartyDetailsListReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_PartyDetailsListReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_PartyDetailsListReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PartyDetailsListReport);
  return pyobj;
}


SWIGINTERN int MsgType_PartyDetailsListRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_PartyDetailsListRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_PartyDetailsListRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PartyDetailsListRequest);
  return pyobj;
}


SWIGINTERN int MsgType_CrossOrderCancelRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_CrossOrderCancelRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_CrossOrderCancelRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_CrossOrderCancelRequest);
  return pyobj;
}


SWIGINTERN int MsgType_NewOrderSingle_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_NewOrderSingle is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_NewOrderSingle_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_NewOrderSingle);
  return pyobj;
}


SWIGINTERN int MsgType_DerivativeSecurityListRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_DerivativeSecurityListRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_DerivativeSecurityListRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_DerivativeSecurityListRequest);
  return pyobj;
}


SWIGINTERN int MsgType_CollateralRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_CollateralRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_CollateralRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_CollateralRequest);
  return pyobj;
}


SWIGINTERN int MsgType_UserNotification_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_UserNotification is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_UserNotification_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_UserNotification);
  return pyobj;
}


SWIGINTERN int MsgType_UserResponse_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_UserResponse is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_UserResponse_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_UserResponse);
  return pyobj;
}


SWIGINTERN int MsgType_DontKnowTrade_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_DontKnowTrade is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_DontKnowTrade_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_DontKnowTrade);
  return pyobj;
}


SWIGINTERN int MsgType_TradeCaptureReportAck_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_TradeCaptureReportAck is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_TradeCaptureReportAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TradeCaptureReportAck);
  return pyobj;
}


SWIGINTERN int MsgType_ApplicationMessageRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_ApplicationMessageRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_ApplicationMessageRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ApplicationMessageRequest);
  return pyobj;
}


SWIGINTERN int MsgType_MultilegOrderCancelReplace_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_MultilegOrderCancelReplace is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_MultilegOrderCancelReplace_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MultilegOrderCancelReplace);
  return pyobj;
}


SWIGINTERN int MsgType_OrderCancelReject_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_OrderCancelReject is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_OrderCancelReject_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_OrderCancelReject);
  return pyobj;
}


SWIGINTERN int MsgType_ExecutionReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_ExecutionReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_ExecutionReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ExecutionReport);
  return pyobj;
}


SWIGINTERN int MsgType_QuoteStatusReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_QuoteStatusReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_QuoteStatusReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_QuoteStatusReport);
  return pyobj;
}


SWIGINTERN int MsgType_ResendRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_ResendRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_ResendRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ResendRequest);
  return pyobj;
}


SWIGINTERN int MsgType_Quote_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_Quote is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_Quote_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_Quote);
  return pyobj;
}


SWIGINTERN int MsgType_SettlementInstructionRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_SettlementInstructionRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_SettlementInstructionRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SettlementInstructionRequest);
  return pyobj;
}


SWIGINTERN int MsgType_SecurityListUpdateReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_SecurityListUpdateReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_SecurityListUpdateReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SecurityListUpdateReport);
  return pyobj;
}


SWIGINTERN int MsgType_AllocationInstructionAlert_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_AllocationInstructionAlert is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_AllocationInstructionAlert_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_AllocationInstructionAlert);
  return pyobj;
}


SWIGINTERN int MsgType_TradeCaptureReportRequestAck_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_TradeCaptureReportRequestAck is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_TradeCaptureReportRequestAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TradeCaptureReportRequestAck);
  return pyobj;
}


SWIGINTERN int MsgType_AllocationInstruction_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_AllocationInstruction is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_AllocationInstruction_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_AllocationInstruction);
  return pyobj;
}


SWIGINTERN int MsgType_Allocation_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_Allocation is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_Allocation_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_Allocation);
  return pyobj;
}


SWIGINTERN int MsgType_ApplicationMessageReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_ApplicationMessageReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_ApplicationMessageReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ApplicationMessageReport);
  return pyobj;
}


SWIGINTERN int MsgType_RegistrationInstructions_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_RegistrationInstructions is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_RegistrationInstructions_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_RegistrationInstructions);
  return pyobj;
}


SWIGINTERN int MsgType_SecurityDefinition_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_SecurityDefinition is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_SecurityDefinition_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SecurityDefinition);
  return pyobj;
}


SWIGINTERN int MsgType_SecurityDefinitionRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_SecurityDefinitionRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_SecurityDefinitionRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SecurityDefinitionRequest);
  return pyobj;
}


SWIGINTERN int MsgType_SecurityStatus_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_SecurityStatus is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_SecurityStatus_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SecurityStatus);
  return pyobj;
}


SWIGINTERN int MsgType_DerivativeSecurityList_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_DerivativeSecurityList is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_DerivativeSecurityList_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_DerivativeSecurityList);
  return pyobj;
}


SWIGINTERN int MsgType_NetworkCounterpartySystemStatusRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_NetworkCounterpartySystemStatusRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_NetworkCounterpartySystemStatusRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_NetworkCounterpartySystemStatusRequest);
  return pyobj;
}


SWIGINTERN int MsgType_MarketDefinitionRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_MarketDefinitionRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_MarketDefinitionRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MarketDefinitionRequest);
  return pyobj;
}


SWIGINTERN int MsgType_Reject_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_Reject is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_Reject_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_Reject);
  return pyobj;
}


SWIGINTERN int MsgType_DerivativeSecurityListUpdateReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_DerivativeSecurityListUpdateReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_DerivativeSecurityListUpdateReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_DerivativeSecurityListUpdateReport);
  return pyobj;
}


SWIGINTERN int MsgType_QuoteRequestReject_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_QuoteRequestReject is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_QuoteRequestReject_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_QuoteRequestReject);
  return pyobj;
}


SWIGINTERN int MsgType_OrderMassStatusRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_OrderMassStatusRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_OrderMassStatusRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_OrderMassStatusRequest);
  return pyobj;
}


SWIGINTERN int MsgType_ApplicationMessageRequestAck_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_ApplicationMessageRequestAck is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_ApplicationMessageRequestAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ApplicationMessageRequestAck);
  return pyobj;
}


SWIGINTERN int MsgType_SecurityStatusRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_SecurityStatusRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_SecurityStatusRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SecurityStatusRequest);
  return pyobj;
}


SWIGINTERN int MsgType_AllocationACK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_AllocationACK is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_AllocationACK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_AllocationACK);
  return pyobj;
}


SWIGINTERN int MsgType_MarketDefinitionUpdateReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_MarketDefinitionUpdateReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_MarketDefinitionUpdateReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MarketDefinitionUpdateReport);
  return pyobj;
}


SWIGINTERN int MsgType_CrossOrderCancelReplaceRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_CrossOrderCancelReplaceRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_CrossOrderCancelReplaceRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_CrossOrderCancelReplaceRequest);
  return pyobj;
}


SWIGINTERN int MsgType_OrderMassCancelReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_OrderMassCancelReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_OrderMassCancelReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_OrderMassCancelReport);
  return pyobj;
}


SWIGINTERN int MsgType_AssignmentReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_AssignmentReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_AssignmentReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_AssignmentReport);
  return pyobj;
}


SWIGINTERN int MsgType_BidResponse_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_BidResponse is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_BidResponse_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_BidResponse);
  return pyobj;
}


SWIGINTERN int MsgType_RequestForPositions_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_RequestForPositions is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_RequestForPositions_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_RequestForPositions);
  return pyobj;
}


SWIGINTERN int MsgType_SettlementObligationReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_SettlementObligationReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_SettlementObligationReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SettlementObligationReport);
  return pyobj;
}


SWIGINTERN int MsgType_OrderMassCancelRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_OrderMassCancelRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_OrderMassCancelRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_OrderMassCancelRequest);
  return pyobj;
}


SWIGINTERN int MsgType_TradingSessionList_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_TradingSessionList is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_TradingSessionList_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TradingSessionList);
  return pyobj;
}


SWIGINTERN int MsgType_OrderStatusRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_OrderStatusRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_OrderStatusRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_OrderStatusRequest);
  return pyobj;
}


SWIGINTERN int MsgType_CollateralAssignment_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_CollateralAssignment is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_CollateralAssignment_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_CollateralAssignment);
  return pyobj;
}


SWIGINTERN int MsgType_StreamAssignmentReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_StreamAssignmentReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_StreamAssignmentReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_StreamAssignmentReport);
  return pyobj;
}


SWIGINTERN int MsgType_OrderMassActionRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_OrderMassActionRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_OrderMassActionRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_OrderMassActionRequest);
  return pyobj;
}


SWIGINTERN int MsgType_AllocationAck_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_AllocationAck is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_AllocationAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_AllocationAck);
  return pyobj;
}


SWIGINTERN int MsgType_QuoteRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_QuoteRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_QuoteRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_QuoteRequest);
  return pyobj;
}


SWIGINTERN int MsgType_CollateralInquiryAck_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_CollateralInquiryAck is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_CollateralInquiryAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_CollateralInquiryAck);
  return pyobj;
}


SWIGINTERN int MsgType_MarketDataSnapshotFullRefresh_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_MarketDataSnapshotFullRefresh is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_MarketDataSnapshotFullRefresh_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MarketDataSnapshotFullRefresh);
  return pyobj;
}


SWIGINTERN int MsgType_SettlementInstructions_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_SettlementInstructions is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_SettlementInstructions_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SettlementInstructions);
  return pyobj;
}


SWIGINTERN int MsgType_OrderCancelReplaceRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_OrderCancelReplaceRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_OrderCancelReplaceRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_OrderCancelReplaceRequest);
  return pyobj;
}


SWIGINTERN int MsgType_TradeCaptureReportRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_TradeCaptureReportRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_TradeCaptureReportRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TradeCaptureReportRequest);
  return pyobj;
}


SWIGINTERN int MsgType_RFQRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_RFQRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_RFQRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_RFQRequest);
  return pyobj;
}


SWIGINTERN int MsgType_OrderCancelRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_OrderCancelRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_OrderCancelRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_OrderCancelRequest);
  return pyobj;
}


SWIGINTERN int MsgType_MultilegOrderCancelReplaceRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_MultilegOrderCancelReplaceRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_MultilegOrderCancelReplaceRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MultilegOrderCancelReplaceRequest);
  return pyobj;
}


SWIGINTERN int MsgType_AllocationInstructionAck_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_AllocationInstructionAck is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_AllocationInstructionAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_AllocationInstructionAck);
  return pyobj;
}


SWIGINTERN int MsgType_MarketDataRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_MarketDataRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_MarketDataRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MarketDataRequest);
  return pyobj;
}


SWIGINTERN int MsgType_MarketDataRequestReject_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_MarketDataRequestReject is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgType_MarketDataRequestReject_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MarketDataRequestReject);
  return pyobj;
}


SWIGINTERN int MultiLegReportingType_SINGLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultiLegReportingType_SINGLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MultiLegReportingType_SINGLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MultiLegReportingType_SINGLE));
  return pyobj;
}


SWIGINTERN int MultiLegReportingType_MULTILEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultiLegReportingType_MULTILEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *MultiLegReportingType_MULTILEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MultiLegReportingType_MULTILEG));
  return pyobj;
}


SWIGINTERN int MultiLegReportingType_SINGLE_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultiLegReportingType_SINGLE_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *MultiLegReportingType_SINGLE_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MultiLegReportingType_SINGLE_SECURITY));
  return pyobj;
}


SWIGINTERN int MultiLegReportingType_MULTI_LEG_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultiLegReportingType_MULTI_LEG_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MultiLegReportingType_INDIVLEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultiLegReportingType_INDIVLEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *MultiLegReportingType_INDIVLEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MultiLegReportingType_INDIVLEG));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 IDSource_EXCHANGE_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IDSource_EXCHANGE_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *IDSource_EXCHANGE_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IDSource_EXCHANGE_SYMBOL);
  return pyobj;
}


SWIGINTERN int IDSource_RIC_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IDSource_RIC_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *IDSource_RIC_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IDSource_RIC_CODE);
  return pyobj;
}


SWIGINTERN int IDSource_ISO_CURRENCY_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IDSource_ISO_CURRENCY_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *IDSource_ISO_CURRENCY_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IDSource_ISO_CURRENCY_CODE);
  return pyobj;
}


SWIGINTERN int IDSource_ISIN_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IDSource_ISIN_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *IDSource_ISIN_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IDSource_ISIN_NUMBER);
  return pyobj;
}


SWIGINTERN int IDSource_SEDOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IDSource_SEDOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *IDSource_SEDOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IDSource_SEDOL);
  return pyobj;
}


SWIGINTERN int IDSource_ISO_COUNTRY_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IDSource_ISO_COUNTRY_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *IDSource_ISO_COUNTRY_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IDSource_ISO_COUNTRY_CODE);
  return pyobj;
}


SWIGINTERN int IDSource_CONSOLIDATED_TAPE_ASSOCIATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IDSource_CONSOLIDATED_TAPE_ASSOCIATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *IDSource_CONSOLIDATED_TAPE_ASSOCIATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IDSource_CONSOLIDATED_TAPE_ASSOCIATION);
  return pyobj;
}


SWIGINTERN int IDSource_QUIK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IDSource_QUIK is read-only.");
  return 1;
}


SWIGINTERN PyObject *IDSource_QUIK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IDSource_QUIK);
  return pyobj;
}


SWIGINTERN int IDSource_CUSIP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IDSource_CUSIP is read-only.");
  return 1;
}


SWIGINTERN PyObject *IDSource_CUSIP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IDSource_CUSIP);
  return pyobj;
}


SWIGINTERN int OrdStatus_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdStatus_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_NEW));
  return pyobj;
}


SWIGINTERN int OrdStatus_CALCULATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_CALCULATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdStatus_CALCULATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_CALCULATED));
  return pyobj;
}


SWIGINTERN int OrdStatus_PENDINGNEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_PENDINGNEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdStatus_PENDINGNEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_PENDINGNEW));
  return pyobj;
}


SWIGINTERN int OrdStatus_PENDING_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_PENDING_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdStatus_PENDING_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_PENDING_CANCEL));
  return pyobj;
}


SWIGINTERN int OrdStatus_PARTIAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_PARTIAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdStatus_PARTIAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_PARTIAL));
  return pyobj;
}


SWIGINTERN int OrdStatus_PENDING_CANCEL_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_PENDING_CANCEL_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 OrdStatus_PENDING_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_PENDING_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdStatus_PENDING_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_PENDING_NEW));
  return pyobj;
}


SWIGINTERN int OrdStatus_STOPPED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_STOPPED is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdStatus_STOPPED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_STOPPED));
  return pyobj;
}


SWIGINTERN int OrdStatus_FILLED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_FILLED is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdStatus_FILLED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_FILLED));
  return pyobj;
}


SWIGINTERN int OrdStatus_PENDING_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_PENDING_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdStatus_PENDING_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_PENDING_REPLACE));
  return pyobj;
}


SWIGINTERN int OrdStatus_CANCELED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_CANCELED is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdStatus_CANCELED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_CANCELED));
  return pyobj;
}


SWIGINTERN int OrdStatus_ACCEPTED_FOR_BIDDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_ACCEPTED_FOR_BIDDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 OrdStatus_SUSPENDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_SUSPENDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdStatus_SUSPENDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_SUSPENDED));
  return pyobj;
}


SWIGINTERN int OrdStatus_DONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_DONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdStatus_DONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_DONE));
  return pyobj;
}


SWIGINTERN int OrdStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int OrdStatus_PARTIALLY_FILLED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_PARTIALLY_FILLED is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdStatus_PARTIALLY_FILLED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_PARTIALLY_FILLED));
  return pyobj;
}


SWIGINTERN int OrdStatus_EXPIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_EXPIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdStatus_EXPIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_EXPIRED));
  return pyobj;
}


SWIGINTERN int OrdStatus_REPLACED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_REPLACED is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdStatus_REPLACED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_REPLACED));
  return pyobj;
}


SWIGINTERN int OrdStatus_DONE_FOR_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_DONE_FOR_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 OrdStatus_ACCEPTBIDDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_ACCEPTBIDDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdStatus_ACCEPTBIDDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_ACCEPTBIDDING));
  return pyobj;
}


SWIGINTERN int OrdStatus_PENDINGREP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_PENDINGREP is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdStatus_PENDINGREP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_PENDINGREP));
  return pyobj;
}


SWIGINTERN int CustomerOrFirm_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustomerOrFirm_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *CustomerOrFirm_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CustomerOrFirm_FIRM));
  return pyobj;
}


SWIGINTERN int CustomerOrFirm_CUSTOMER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustomerOrFirm_CUSTOMER is read-only.");
  return 1;
}


SWIGINTERN PyObject *CustomerOrFirm_CUSTOMER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CustomerOrFirm_CUSTOMER));
  return pyobj;
}


SWIGINTERN int AdjustmentType_DELTA_MINUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdjustmentType_DELTA_MINUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *AdjustmentType_DELTA_MINUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AdjustmentType_DELTA_MINUS));
  return pyobj;
}


SWIGINTERN int AdjustmentType_DELTAPLUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdjustmentType_DELTAPLUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *AdjustmentType_DELTAPLUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AdjustmentType_DELTAPLUS));
  return pyobj;
}


SWIGINTERN int AdjustmentType_DELTA_PLUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdjustmentType_DELTA_PLUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *AdjustmentType_DELTA_PLUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AdjustmentType_DELTA_PLUS));
  return pyobj;
}


SWIGINTERN int AdjustmentType_DELTAMINUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdjustmentType_DELTAMINUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *AdjustmentType_DELTAMINUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AdjustmentType_DELTAMINUS));
  return pyobj;
}


SWIGINTERN int AdjustmentType_FINAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdjustmentType_FINAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *AdjustmentType_FINAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AdjustmentType_FINAL));
  return pyobj;
}


SWIGINTERN int AdjustmentType_PROCESSREQUESTASMARGINDISPOSITION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdjustmentType_PROCESSREQUESTASMARGINDISPOSITION is read-only.");
  return 1;
}


SWIGINTERN PyObject *AdjustmentType_PROCESSREQUESTASMARGINDISPOSITION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AdjustmentType_PROCESSREQUESTASMARGINDISPOSITION));
  return pyobj;
}


SWIGINTERN int 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 *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 AsOfIndicator_TRUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AsOfIndicator_TRUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *AsOfIndicator_TRUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AsOfIndicator_TRUE));
  return pyobj;
}


SWIGINTERN int AsOfIndicator_FALSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AsOfIndicator_FALSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *AsOfIndicator_FALSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AsOfIndicator_FALSE));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 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 *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 MassActionScope_ALL_ORDERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionScope_ALL_ORDERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassActionScope_ALL_ORDERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionScope_ALL_ORDERS));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 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 *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 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 *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 MassActionScope_CANCEL_FOR_SECURITY_ISSUER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionScope_CANCEL_FOR_SECURITY_ISSUER is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 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 *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 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 *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 VenueType_PIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VenueType_PIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *VenueType_PIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::VenueType_PIT));
  return pyobj;
}


SWIGINTERN int VenueType_EX_PIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VenueType_EX_PIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *VenueType_EX_PIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::VenueType_EX_PIT));
  return pyobj;
}


SWIGINTERN int VenueType_ELECTRONIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VenueType_ELECTRONIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *VenueType_ELECTRONIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::VenueType_ELECTRONIC));
  return pyobj;
}


SWIGINTERN int MassActionType_CANCEL_ORDERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionType_CANCEL_ORDERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassActionType_CANCEL_ORDERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionType_CANCEL_ORDERS));
  return pyobj;
}


SWIGINTERN int MassActionType_RELEASE_ORDERS_FROM_SUSPENSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionType_RELEASE_ORDERS_FROM_SUSPENSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MassActionType_SUSPEND_ORDERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionType_SUSPEND_ORDERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassActionType_SUSPEND_ORDERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionType_SUSPEND_ORDERS));
  return pyobj;
}


SWIGINTERN int PosMaintResult_SUCCESSFULCOMPLETION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintResult_SUCCESSFULCOMPLETION is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosMaintResult_SUCCESSFULCOMPLETION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintResult_SUCCESSFULCOMPLETION));
  return pyobj;
}


SWIGINTERN int PosMaintResult_SUCCESSFUL_COMPLETION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintResult_SUCCESSFUL_COMPLETION is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosMaintResult_SUCCESSFUL_COMPLETION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintResult_SUCCESSFUL_COMPLETION));
  return pyobj;
}


SWIGINTERN int PosMaintResult_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintResult_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosMaintResult_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintResult_OTHER));
  return pyobj;
}


SWIGINTERN int PosMaintResult_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintResult_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosMaintResult_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintResult_REJECTED));
  return pyobj;
}


SWIGINTERN int IOIShares_MEDIUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIShares_MEDIUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIShares_MEDIUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IOIShares_MEDIUM);
  return pyobj;
}


SWIGINTERN int IOIShares_LARGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIShares_LARGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIShares_LARGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IOIShares_LARGE);
  return pyobj;
}


SWIGINTERN int IOIShares_SMALL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIShares_SMALL is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIShares_SMALL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IOIShares_SMALL);
  return pyobj;
}


SWIGINTERN int PegOffsetType_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegOffsetType_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PegOffsetType_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegOffsetType_PRICE));
  return pyobj;
}


SWIGINTERN int PegOffsetType_BASISPOINTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegOffsetType_BASISPOINTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *PegOffsetType_BASISPOINTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegOffsetType_BASISPOINTS));
  return pyobj;
}


SWIGINTERN int PegOffsetType_PRICE_TIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegOffsetType_PRICE_TIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *PegOffsetType_PRICE_TIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegOffsetType_PRICE_TIER));
  return pyobj;
}


SWIGINTERN int PegOffsetType_TICKS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegOffsetType_TICKS is read-only.");
  return 1;
}


SWIGINTERN PyObject *PegOffsetType_TICKS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegOffsetType_TICKS));
  return pyobj;
}


SWIGINTERN int PegOffsetType_PRICETIERLEVEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegOffsetType_PRICETIERLEVEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *PegOffsetType_PRICETIERLEVEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegOffsetType_PRICETIERLEVEL));
  return pyobj;
}


SWIGINTERN int PegOffsetType_BASIS_POINTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegOffsetType_BASIS_POINTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *PegOffsetType_BASIS_POINTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegOffsetType_BASIS_POINTS));
  return pyobj;
}


SWIGINTERN int 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 *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 MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MassCancelRejectReason_INVALIDSECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALIDSECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassCancelRejectReason_INVALIDSECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALIDSECURITY));
  return pyobj;
}


SWIGINTERN int MassCancelRejectReason_MASS_CANCEL_NOT_SUPPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_MASS_CANCEL_NOT_SUPPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 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 *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 MassCancelRejectReason_INVALIDPRODUCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALIDPRODUCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassCancelRejectReason_INVALIDPRODUCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALIDPRODUCT));
  return pyobj;
}


SWIGINTERN int 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 *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 MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MassCancelRejectReason_INVALID_OR_UNKNOWN_CFICODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALID_OR_UNKNOWN_CFICODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 MassCancelRejectReason_INVALID_OR_UNKNOWN_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALID_OR_UNKNOWN_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 MassCancelRejectReason_INVALIDUNDERLYING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALIDUNDERLYING is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassCancelRejectReason_INVALIDUNDERLYING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALIDUNDERLYING));
  return pyobj;
}


SWIGINTERN int MassCancelRejectReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassCancelRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_OTHER));
  return pyobj;
}


SWIGINTERN int 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 *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 MassCancelRejectReason_INVALIDCFICODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALIDCFICODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassCancelRejectReason_INVALIDCFICODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALIDCFICODE));
  return pyobj;
}


SWIGINTERN int MassCancelRejectReason_INVALIDSECURITYTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALIDSECURITYTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassCancelRejectReason_INVALIDSECURITYTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALIDSECURITYTYPE));
  return pyobj;
}


SWIGINTERN int MassCancelRejectReason_INVALID_OR_UNKNOWN_PRODUCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALID_OR_UNKNOWN_PRODUCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MassCancelRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALID_OR_UNKNOWN_UNDERLYING is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MassCancelRejectReason_INVALIDTRDSESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALIDTRDSESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassCancelRejectReason_INVALIDTRDSESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALIDTRDSESSION));
  return pyobj;
}


SWIGINTERN int MassCancelRejectReason_MASSCXLNOTSUPPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_MASSCXLNOTSUPPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassCancelRejectReason_MASSCXLNOTSUPPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_MASSCXLNOTSUPPORTED));
  return pyobj;
}


SWIGINTERN int ResponseTransportType_OUTOFBAND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ResponseTransportType_OUTOFBAND is read-only.");
  return 1;
}


SWIGINTERN PyObject *ResponseTransportType_OUTOFBAND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ResponseTransportType_OUTOFBAND));
  return pyobj;
}


SWIGINTERN int ResponseTransportType_INBAND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ResponseTransportType_INBAND is read-only.");
  return 1;
}


SWIGINTERN PyObject *ResponseTransportType_INBAND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ResponseTransportType_INBAND));
  return pyobj;
}


SWIGINTERN int ResponseTransportType_OUT_OF_BAND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ResponseTransportType_OUT_OF_BAND is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TradSesStatusRejReason_UNKNOWN_OR_INVALID_TRADINGSESSIONID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesStatusRejReason_UNKNOWN_OR_INVALID_TRADINGSESSIONID is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TradSesStatusRejReason_UNKNOWNTRADINGSESSIONID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesStatusRejReason_UNKNOWNTRADINGSESSIONID is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradSesStatusRejReason_UNKNOWNTRADINGSESSIONID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesStatusRejReason_UNKNOWNTRADINGSESSIONID));
  return pyobj;
}


SWIGINTERN int TradSesStatusRejReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesStatusRejReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradSesStatusRejReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesStatusRejReason_OTHER));
  return pyobj;
}


SWIGINTERN int TrdRegTimestampType_EXECUTION_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_EXECUTION_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdRegTimestampType_EXECUTION_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_EXECUTION_TIME));
  return pyobj;
}


SWIGINTERN int TrdRegTimestampType_BROKEREXECUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_BROKEREXECUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdRegTimestampType_BROKEREXECUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_BROKEREXECUTION));
  return pyobj;
}


SWIGINTERN int TrdRegTimestampType_BROKERRECEIPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_BROKERRECEIPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdRegTimestampType_BROKERRECEIPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_BROKERRECEIPT));
  return pyobj;
}


SWIGINTERN int TrdRegTimestampType_TIMEIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_TIMEIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdRegTimestampType_TIMEIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_TIMEIN));
  return pyobj;
}


SWIGINTERN int TrdRegTimestampType_TIME_IN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_TIME_IN is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdRegTimestampType_TIME_IN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_TIME_IN));
  return pyobj;
}


SWIGINTERN int TrdRegTimestampType_TIMEOUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_TIMEOUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdRegTimestampType_TIMEOUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_TIMEOUT));
  return pyobj;
}


SWIGINTERN int TrdRegTimestampType_SUBMISSION_TO_CLEARING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_SUBMISSION_TO_CLEARING is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdRegTimestampType_BROKER_RECEIPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_BROKER_RECEIPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdRegTimestampType_BROKER_RECEIPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_BROKER_RECEIPT));
  return pyobj;
}


SWIGINTERN int TrdRegTimestampType_DESK_RECEIPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_DESK_RECEIPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdRegTimestampType_DESK_RECEIPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_DESK_RECEIPT));
  return pyobj;
}


SWIGINTERN int TrdRegTimestampType_EXECUTIONTIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_EXECUTIONTIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdRegTimestampType_EXECUTIONTIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_EXECUTIONTIME));
  return pyobj;
}


SWIGINTERN int TrdRegTimestampType_BROKER_EXECUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_BROKER_EXECUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdRegTimestampType_BROKER_EXECUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_BROKER_EXECUTION));
  return pyobj;
}


SWIGINTERN int TrdRegTimestampType_TIME_OUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_TIME_OUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdRegTimestampType_TIME_OUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_TIME_OUT));
  return pyobj;
}


SWIGINTERN int ApplVerID_FIX50SP1_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplVerID_FIX50SP1 is read-only.");
  return 1;
}


SWIGINTERN PyObject *ApplVerID_FIX50SP1_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ApplVerID_FIX50SP1);
  return pyobj;
}


SWIGINTERN int ApplVerID_FIX27_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplVerID_FIX27 is read-only.");
  return 1;
}


SWIGINTERN PyObject *ApplVerID_FIX27_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ApplVerID_FIX27);
  return pyobj;
}


SWIGINTERN int ApplVerID_FIX50SP2_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplVerID_FIX50SP2 is read-only.");
  return 1;
}


SWIGINTERN PyObject *ApplVerID_FIX50SP2_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ApplVerID_FIX50SP2);
  return pyobj;
}


SWIGINTERN int ApplVerID_FIX50_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplVerID_FIX50 is read-only.");
  return 1;
}


SWIGINTERN PyObject *ApplVerID_FIX50_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ApplVerID_FIX50);
  return pyobj;
}


SWIGINTERN int ApplVerID_FIX40_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplVerID_FIX40 is read-only.");
  return 1;
}


SWIGINTERN PyObject *ApplVerID_FIX40_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ApplVerID_FIX40);
  return pyobj;
}


SWIGINTERN int ApplVerID_FIX41_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplVerID_FIX41 is read-only.");
  return 1;
}


SWIGINTERN PyObject *ApplVerID_FIX41_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ApplVerID_FIX41);
  return pyobj;
}


SWIGINTERN int ApplVerID_FIX30_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplVerID_FIX30 is read-only.");
  return 1;
}


SWIGINTERN PyObject *ApplVerID_FIX30_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ApplVerID_FIX30);
  return pyobj;
}


SWIGINTERN int ApplVerID_FIX42_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplVerID_FIX42 is read-only.");
  return 1;
}


SWIGINTERN PyObject *ApplVerID_FIX42_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ApplVerID_FIX42);
  return pyobj;
}


SWIGINTERN int ApplVerID_FIX43_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplVerID_FIX43 is read-only.");
  return 1;
}


SWIGINTERN PyObject *ApplVerID_FIX43_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ApplVerID_FIX43);
  return pyobj;
}


SWIGINTERN int ApplVerID_FIX44_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplVerID_FIX44 is read-only.");
  return 1;
}


SWIGINTERN PyObject *ApplVerID_FIX44_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ApplVerID_FIX44);
  return pyobj;
}


SWIGINTERN int HandlInst_MANUAL_ORDER_BEST_EXECUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HandlInst_MANUAL_ORDER_BEST_EXECUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 HandlInst_AUTOEXECPUB_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HandlInst_AUTOEXECPUB is read-only.");
  return 1;
}


SWIGINTERN PyObject *HandlInst_AUTOEXECPUB_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HandlInst_AUTOEXECPUB));
  return pyobj;
}


SWIGINTERN int 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 *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 HandlInst_AUTOEXECPRIV_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HandlInst_AUTOEXECPRIV is read-only.");
  return 1;
}


SWIGINTERN PyObject *HandlInst_AUTOEXECPRIV_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HandlInst_AUTOEXECPRIV));
  return pyobj;
}


SWIGINTERN int 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 *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 HandlInst_MANUAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HandlInst_MANUAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *HandlInst_MANUAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HandlInst_MANUAL));
  return pyobj;
}


SWIGINTERN int TradingSessionSubID_POST_TRADING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionSubID_POST_TRADING is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradingSessionSubID_POST_TRADING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionSubID_POST_TRADING);
  return pyobj;
}


SWIGINTERN int TradingSessionSubID_INTRADAY_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionSubID_INTRADAY_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradingSessionSubID_INTRADAY_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionSubID_INTRADAY_AUCTION);
  return pyobj;
}


SWIGINTERN int TradingSessionSubID_PRE_TRADING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionSubID_PRE_TRADING is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradingSessionSubID_PRE_TRADING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionSubID_PRE_TRADING);
  return pyobj;
}


SWIGINTERN int TradingSessionSubID_QUIESCENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionSubID_QUIESCENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradingSessionSubID_QUIESCENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionSubID_QUIESCENT);
  return pyobj;
}


SWIGINTERN int TradingSessionSubID_3_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionSubID_3 is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradingSessionSubID_3_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionSubID_3);
  return pyobj;
}


SWIGINTERN int TradingSessionSubID_OPENING_OR_OPENING_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionSubID_OPENING_OR_OPENING_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradingSessionSubID_OPENING_OR_OPENING_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionSubID_OPENING_OR_OPENING_AUCTION);
  return pyobj;
}


SWIGINTERN int TradingSessionSubID_CLOSING_OR_CLOSING_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionSubID_CLOSING_OR_CLOSING_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradingSessionSubID_CLOSING_OR_CLOSING_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionSubID_CLOSING_OR_CLOSING_AUCTION);
  return pyobj;
}


SWIGINTERN int MDEntryType_SWAP_VALUE_FACTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_SWAP_VALUE_FACTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MDEntryType_OPEN_INTEREST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_OPEN_INTEREST is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDEntryType_OPEN_INTEREST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_OPEN_INTEREST));
  return pyobj;
}


SWIGINTERN int MDEntryType_COMPOSITE_UNDERLYING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_COMPOSITE_UNDERLYING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MDEntryType_SESSION_HIGH_BID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_SESSION_HIGH_BID is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MDEntryType_INDEXVALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_INDEXVALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDEntryType_INDEXVALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_INDEXVALUE));
  return pyobj;
}


SWIGINTERN int MDEntryType_OPENINTEREST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_OPENINTEREST is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDEntryType_OPENINTEREST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_OPENINTEREST));
  return pyobj;
}


SWIGINTERN int MDEntryType_CLOSING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_CLOSING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDEntryType_CLOSING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_CLOSING_PRICE));
  return pyobj;
}


SWIGINTERN int MDEntryType_PRIOR_SETTLE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_PRIOR_SETTLE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MDEntryType_TRADING_SESSION_VWAP_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_TRADING_SESSION_VWAP_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MDEntryType_TRADING_SESSION_LOW_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_TRADING_SESSION_LOW_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MDEntryType_SETTLE_HIGH_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_SETTLE_HIGH_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MDEntryType_IMBALANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_IMBALANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDEntryType_IMBALANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_IMBALANCE));
  return pyobj;
}


SWIGINTERN int MDEntryType_FIXING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_FIXING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDEntryType_FIXING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_FIXING_PRICE));
  return pyobj;
}


SWIGINTERN int MDEntryType_CASH_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_CASH_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDEntryType_CASH_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_CASH_RATE));
  return pyobj;
}


SWIGINTERN int MDEntryType_CLOSING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_CLOSING is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDEntryType_CLOSING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_CLOSING));
  return pyobj;
}


SWIGINTERN int MDEntryType_OPENING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_OPENING is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDEntryType_OPENING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_OPENING));
  return pyobj;
}


SWIGINTERN int MDEntryType_OPENING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_OPENING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDEntryType_OPENING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_OPENING_PRICE));
  return pyobj;
}


SWIGINTERN int MDEntryType_TRADINGHIGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_TRADINGHIGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDEntryType_TRADINGHIGH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_TRADINGHIGH));
  return pyobj;
}


SWIGINTERN int MDEntryType_TRADEVOLUME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_TRADEVOLUME is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDEntryType_TRADEVOLUME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_TRADEVOLUME));
  return pyobj;
}


SWIGINTERN int MDEntryType_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDEntryType_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_TRADE));
  return pyobj;
}


SWIGINTERN int 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 *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 MDEntryType_SIMULATED_SELL_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_SIMULATED_SELL_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MDEntryType_EMPTY_BOOK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_EMPTY_BOOK is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDEntryType_EMPTY_BOOK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_EMPTY_BOOK));
  return pyobj;
}


SWIGINTERN int MDEntryType_AUCTION_CLEARING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_AUCTION_CLEARING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MDEntryType_BID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_BID is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDEntryType_BID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_BID));
  return pyobj;
}


SWIGINTERN int MDEntryType_RECOVERY_RATE_FOR_SHORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_RECOVERY_RATE_FOR_SHORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MDEntryType_SIMULATED_BUY_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_SIMULATED_BUY_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MDEntryType_EARLY_PRICES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_EARLY_PRICES is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDEntryType_EARLY_PRICES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_EARLY_PRICES));
  return pyobj;
}


SWIGINTERN int MDEntryType_TRADINGLOW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_TRADINGLOW is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDEntryType_TRADINGLOW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_TRADINGLOW));
  return pyobj;
}


SWIGINTERN int MDEntryType_TRADING_SESSION_HIGH_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_TRADING_SESSION_HIGH_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MDEntryType_INDEX_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_INDEX_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDEntryType_INDEX_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_INDEX_VALUE));
  return pyobj;
}


SWIGINTERN int MDEntryType_RECOVERY_RATE_FOR_LONG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_RECOVERY_RATE_FOR_LONG is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 MDEntryType_MID_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_MID_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDEntryType_MID_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_MID_PRICE));
  return pyobj;
}


SWIGINTERN int MDEntryType_SETTLEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_SETTLEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDEntryType_SETTLEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_SETTLEMENT));
  return pyobj;
}


SWIGINTERN int MDEntryType_RECOVERY_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_RECOVERY_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDEntryType_RECOVERY_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_RECOVERY_RATE));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 MDEntryType_TRADE_VOLUME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_TRADE_VOLUME is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDEntryType_TRADE_VOLUME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_TRADE_VOLUME));
  return pyobj;
}


SWIGINTERN int MDEntryType_MARGIN_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_MARGIN_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDEntryType_MARGIN_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_MARGIN_RATE));
  return pyobj;
}


SWIGINTERN int MDEntryType_SETTLE_LOW_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_SETTLE_LOW_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MDEntryType_SESSION_LOW_OFFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_SESSION_LOW_OFFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MDEntryType_TRADINGVWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_TRADINGVWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDEntryType_TRADINGVWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_TRADINGVWAP));
  return pyobj;
}


SWIGINTERN int MDEntryType_SETTLEMENT_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_SETTLEMENT_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDEntryType_SETTLEMENT_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_SETTLEMENT_PRICE));
  return pyobj;
}


SWIGINTERN int MDEntryType_OFFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_OFFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDEntryType_OFFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_OFFER));
  return pyobj;
}


SWIGINTERN int PegMoveType_FLOATING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegMoveType_FLOATING is read-only.");
  return 1;
}


SWIGINTERN PyObject *PegMoveType_FLOATING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegMoveType_FLOATING));
  return pyobj;
}


SWIGINTERN int PegMoveType_FIXED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegMoveType_FIXED is read-only.");
  return 1;
}


SWIGINTERN PyObject *PegMoveType_FIXED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegMoveType_FIXED));
  return pyobj;
}


SWIGINTERN int AvgPxIndicator_NOAVERAGEPRICING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AvgPxIndicator_NOAVERAGEPRICING is read-only.");
  return 1;
}


SWIGINTERN PyObject *AvgPxIndicator_NOAVERAGEPRICING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AvgPxIndicator_NOAVERAGEPRICING));
  return pyobj;
}


SWIGINTERN int AvgPxIndicator_NO_AVERAGE_PRICING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AvgPxIndicator_NO_AVERAGE_PRICING is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 AvgPxIndicator_LASTTRADEAVERAGEPRICEGROUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AvgPxIndicator_LASTTRADEAVERAGEPRICEGROUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *AvgPxIndicator_LASTTRADEAVERAGEPRICEGROUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AvgPxIndicator_LASTTRADEAVERAGEPRICEGROUP));
  return pyobj;
}


SWIGINTERN int 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 *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 AvgPxIndicator_TRADEAVERAGEPRICEGROUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AvgPxIndicator_TRADEAVERAGEPRICEGROUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *AvgPxIndicator_TRADEAVERAGEPRICEGROUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AvgPxIndicator_TRADEAVERAGEPRICEGROUP));
  return pyobj;
}


SWIGINTERN int 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 *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 CancellationRights_NO_WAIVER_AGREEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CancellationRights_NO_WAIVER_AGREEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 CancellationRights_NO_M_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CancellationRights_NO_M is read-only.");
  return 1;
}


SWIGINTERN PyObject *CancellationRights_NO_M_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CancellationRights_NO_M));
  return pyobj;
}


SWIGINTERN int CancellationRights_NO_N_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CancellationRights_NO_N is read-only.");
  return 1;
}


SWIGINTERN PyObject *CancellationRights_NO_N_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CancellationRights_NO_N));
  return pyobj;
}


SWIGINTERN int CancellationRights_NOINSTIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CancellationRights_NOINSTIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *CancellationRights_NOINSTIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CancellationRights_NOINSTIT));
  return pyobj;
}


SWIGINTERN int CancellationRights_NO_INSTITUTIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CancellationRights_NO_INSTITUTIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *CancellationRights_NO_INSTITUTIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CancellationRights_NO_INSTITUTIONAL));
  return pyobj;
}


SWIGINTERN int CancellationRights_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CancellationRights_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *CancellationRights_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CancellationRights_YES));
  return pyobj;
}


SWIGINTERN int CancellationRights_NO_O_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CancellationRights_NO_O is read-only.");
  return 1;
}


SWIGINTERN PyObject *CancellationRights_NO_O_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CancellationRights_NO_O));
  return pyobj;
}


SWIGINTERN int CancellationRights_NOEXECONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CancellationRights_NOEXECONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *CancellationRights_NOEXECONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CancellationRights_NOEXECONLY));
  return pyobj;
}


SWIGINTERN int CancellationRights_NO_EXECUTION_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CancellationRights_NO_EXECUTION_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 CancellationRights_NOWAIVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CancellationRights_NOWAIVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *CancellationRights_NOWAIVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CancellationRights_NOWAIVER));
  return pyobj;
}


SWIGINTERN int ExecPriceType_CREATIONPRICEADJAMT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecPriceType_CREATIONPRICEADJAMT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecPriceType_CREATIONPRICEADJAMT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_CREATIONPRICEADJAMT));
  return pyobj;
}


SWIGINTERN int ExecPriceType_CREATION_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecPriceType_CREATION_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecPriceType_CREATION_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_CREATION_PRICE));
  return pyobj;
}


SWIGINTERN int ExecPriceType_CREATIONPRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecPriceType_CREATIONPRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecPriceType_CREATIONPRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_CREATIONPRICE));
  return pyobj;
}


SWIGINTERN int ExecPriceType_SINGLEPRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecPriceType_SINGLEPRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecPriceType_SINGLEPRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_SINGLEPRICE));
  return pyobj;
}


SWIGINTERN int 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 *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 ExecPriceType_OFFERPRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecPriceType_OFFERPRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecPriceType_OFFERPRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_OFFERPRICE));
  return pyobj;
}


SWIGINTERN int ExecPriceType_BIDPRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecPriceType_BIDPRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecPriceType_BIDPRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_BIDPRICE));
  return pyobj;
}


SWIGINTERN int ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecPriceType_CREATIONPRICEADJPCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecPriceType_CREATIONPRICEADJPCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecPriceType_CREATIONPRICEADJPCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_CREATIONPRICEADJPCT));
  return pyobj;
}


SWIGINTERN int 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 *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 ExecPriceType_OFFERPRICEMINUSADJAMT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecPriceType_OFFERPRICEMINUSADJAMT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecPriceType_OFFERPRICEMINUSADJAMT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_OFFERPRICEMINUSADJAMT));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 ExecPriceType_OFFERPRICEMINUSADJPCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecPriceType_OFFERPRICEMINUSADJPCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecPriceType_OFFERPRICEMINUSADJPCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_OFFERPRICEMINUSADJPCT));
  return pyobj;
}


SWIGINTERN int ExecPriceType_BID_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecPriceType_BID_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecPriceType_BID_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_BID_PRICE));
  return pyobj;
}


SWIGINTERN int ExecPriceType_SINGLE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecPriceType_SINGLE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecPriceType_SINGLE_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_SINGLE_PRICE));
  return pyobj;
}


SWIGINTERN int ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecPriceType_OFFER_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecPriceType_OFFER_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecPriceType_OFFER_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_OFFER_PRICE));
  return pyobj;
}


SWIGINTERN int AllocSettlInstType_PHONEFORINSTRUCTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocSettlInstType_PHONEFORINSTRUCTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocSettlInstType_PHONEFORINSTRUCTIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocSettlInstType_PHONEFORINSTRUCTIONS));
  return pyobj;
}


SWIGINTERN int AllocSettlInstType_SSIDBIDSPROVIDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocSettlInstType_SSIDBIDSPROVIDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocSettlInstType_SSIDBIDSPROVIDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocSettlInstType_SSIDBIDSPROVIDED));
  return pyobj;
}


SWIGINTERN int AllocSettlInstType_FULLDETAILSPROVIDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocSettlInstType_FULLDETAILSPROVIDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocSettlInstType_FULLDETAILSPROVIDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocSettlInstType_FULLDETAILSPROVIDED));
  return pyobj;
}


SWIGINTERN int AllocSettlInstType_USEDEFAULTINSTRUCTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocSettlInstType_USEDEFAULTINSTRUCTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocSettlInstType_USEDEFAULTINSTRUCTIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocSettlInstType_USEDEFAULTINSTRUCTIONS));
  return pyobj;
}


SWIGINTERN int AllocSettlInstType_SSI_DB_IDS_PROVIDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocSettlInstType_SSI_DB_IDS_PROVIDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 AllocSettlInstType_PHONE_FOR_INSTRUCTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocSettlInstType_PHONE_FOR_INSTRUCTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 AllocSettlInstType_DERIVE_FROM_PARAMETERS_PROVIDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocSettlInstType_DERIVE_FROM_PARAMETERS_PROVIDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 AllocSettlInstType_FULL_DETAILS_PROVIDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocSettlInstType_FULL_DETAILS_PROVIDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 AllocSettlInstType_USE_DEFAULT_INSTRUCTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocSettlInstType_USE_DEFAULT_INSTRUCTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 AllocSettlInstType_DERIVEFROMPARAMETERSPROVIDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocSettlInstType_DERIVEFROMPARAMETERSPROVIDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocSettlInstType_DERIVEFROMPARAMETERSPROVIDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocSettlInstType_DERIVEFROMPARAMETERSPROVIDED));
  return pyobj;
}


SWIGINTERN int StatsType_AVERAGE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StatsType_AVERAGE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StatsType_AVERAGE_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StatsType_AVERAGE_PRICE));
  return pyobj;
}


SWIGINTERN int StatsType_HIGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StatsType_HIGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *StatsType_HIGH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StatsType_HIGH));
  return pyobj;
}


SWIGINTERN int StatsType_EXCHANGE_LAST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StatsType_EXCHANGE_LAST is read-only.");
  return 1;
}


SWIGINTERN PyObject *StatsType_EXCHANGE_LAST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StatsType_EXCHANGE_LAST));
  return pyobj;
}


SWIGINTERN int StatsType_TURNOVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StatsType_TURNOVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *StatsType_TURNOVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StatsType_TURNOVER));
  return pyobj;
}


SWIGINTERN int TradSesMode_SIMULATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesMode_SIMULATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradSesMode_SIMULATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesMode_SIMULATED));
  return pyobj;
}


SWIGINTERN int TradSesMode_PRODUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesMode_PRODUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradSesMode_PRODUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesMode_PRODUCTION));
  return pyobj;
}


SWIGINTERN int TradSesMode_TESTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesMode_TESTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradSesMode_TESTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesMode_TESTING));
  return pyobj;
}


SWIGINTERN int SettlInstSource_INSTITUTIONS_INSTRUCTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstSource_INSTITUTIONS_INSTRUCTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlInstSource_INSTITUTIONS_INSTRUCTIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstSource_INSTITUTIONS_INSTRUCTIONS));
  return pyobj;
}


SWIGINTERN int SettlInstSource_BROKERS_INSTRUCTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstSource_BROKERS_INSTRUCTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlInstSource_BROKERS_INSTRUCTIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstSource_BROKERS_INSTRUCTIONS));
  return pyobj;
}


SWIGINTERN int SettlInstSource_INVESTORCIV_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstSource_INVESTORCIV is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlInstSource_INVESTORCIV_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstSource_INVESTORCIV));
  return pyobj;
}


SWIGINTERN int SettlInstSource_INVESTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstSource_INVESTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlInstSource_INVESTOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstSource_INVESTOR));
  return pyobj;
}


SWIGINTERN int SettlInstSource_INSTINSTR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstSource_INSTINSTR is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlInstSource_INSTINSTR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstSource_INSTINSTR));
  return pyobj;
}


SWIGINTERN int SettlInstSource_BROKERINSTR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstSource_BROKERINSTR is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlInstSource_BROKERINSTR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstSource_BROKERINSTR));
  return pyobj;
}


SWIGINTERN int ExpType_DIFFERENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpType_DIFFERENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExpType_DIFFERENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpType_DIFFERENCE));
  return pyobj;
}


SWIGINTERN int ExpType_FINAL_WILL_BE_EXERCISED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpType_FINAL_WILL_BE_EXERCISED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExpType_NON_AUTO_EXERCISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpType_NON_AUTO_EXERCISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExpType_CONTRARY_INTENTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpType_CONTRARY_INTENTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExpType_CONTRARY_INTENTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpType_CONTRARY_INTENTION));
  return pyobj;
}


SWIGINTERN int ExpType_AUTO_EXERCISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpType_AUTO_EXERCISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExpType_AUTO_EXERCISE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpType_AUTO_EXERCISE));
  return pyobj;
}


SWIGINTERN int SettlInstTransType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstTransType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlInstTransType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstTransType_REPLACE));
  return pyobj;
}


SWIGINTERN int SettlInstTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlInstTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstTransType_NEW));
  return pyobj;
}


SWIGINTERN int SettlInstTransType_RESTATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstTransType_RESTATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlInstTransType_RESTATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstTransType_RESTATE));
  return pyobj;
}


SWIGINTERN int SettlInstTransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstTransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlInstTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstTransType_CANCEL));
  return pyobj;
}


SWIGINTERN int TradeRequestResult_TRADEREQUESTTYPENOTSUPPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_TRADEREQUESTTYPENOTSUPPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeRequestResult_TRADEREQUESTTYPENOTSUPPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_TRADEREQUESTTYPENOTSUPPORTED));
  return pyobj;
}


SWIGINTERN int TradeRequestResult_INVALIDORUNKNOWNINSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_INVALIDORUNKNOWNINSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeRequestResult_INVALIDORUNKNOWNINSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_INVALIDORUNKNOWNINSTRUMENT));
  return pyobj;
}


SWIGINTERN int TradeRequestResult_INVALID_DESTINATION_REQUESTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_INVALID_DESTINATION_REQUESTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 TradeRequestResult_INVALIDTRANSPORTTYPEREQUESTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_INVALIDTRANSPORTTYPEREQUESTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeRequestResult_INVALIDTRANSPORTTYPEREQUESTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_INVALIDTRANSPORTTYPEREQUESTED));
  return pyobj;
}


SWIGINTERN int TradeRequestResult_INVALIDPARTIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_INVALIDPARTIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeRequestResult_INVALIDPARTIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_INVALIDPARTIES));
  return pyobj;
}


SWIGINTERN int TradeRequestResult_INVALIDDESTINATIONREQUESTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_INVALIDDESTINATIONREQUESTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeRequestResult_INVALIDDESTINATIONREQUESTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_INVALIDDESTINATIONREQUESTED));
  return pyobj;
}


SWIGINTERN int TradeRequestResult_SUCCESSFUL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_SUCCESSFUL is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeRequestResult_SUCCESSFUL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_SUCCESSFUL));
  return pyobj;
}


SWIGINTERN int TradeRequestResult_INVALID_OR_UNKNOWN_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_INVALID_OR_UNKNOWN_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TradeRequestResult_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeRequestResult_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_OTHER));
  return pyobj;
}


SWIGINTERN int 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 *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 TradeRequestResult_INVALID_PARTIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_INVALID_PARTIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeRequestResult_INVALID_PARTIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_INVALID_PARTIES));
  return pyobj;
}


SWIGINTERN int TradeRequestResult_UNAUTHORIZEDFORTRADECAPTUREREPORTREQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_UNAUTHORIZEDFORTRADECAPTUREREPORTREQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeRequestResult_UNAUTHORIZEDFORTRADECAPTUREREPORTREQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_UNAUTHORIZEDFORTRADECAPTUREREPORTREQUEST));
  return pyobj;
}


SWIGINTERN int TradeRequestResult_NOT_AUTHORIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_NOT_AUTHORIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeRequestResult_NOT_AUTHORIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_NOT_AUTHORIZED));
  return pyobj;
}


SWIGINTERN int TradeRequestResult_INVALID_TRANSPORT_TYPE_REQUESTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_INVALID_TRANSPORT_TYPE_REQUESTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TradeRequestResult_INVALIDTYPEOFTRADEREQUESTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_INVALIDTYPEOFTRADEREQUESTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeRequestResult_INVALIDTYPEOFTRADEREQUESTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_INVALIDTYPEOFTRADEREQUESTED));
  return pyobj;
}


SWIGINTERN int TradeRequestResult_TRADEREQUESTTYPE_NOT_SUPPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_TRADEREQUESTTYPE_NOT_SUPPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TestMessageIndicator_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TestMessageIndicator_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *TestMessageIndicator_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TestMessageIndicator_NO));
  return pyobj;
}


SWIGINTERN int TestMessageIndicator_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TestMessageIndicator_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *TestMessageIndicator_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TestMessageIndicator_YES));
  return pyobj;
}


SWIGINTERN int 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 *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 ExpirationCycle_EXPIREONTRADINGSESSIONOPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpirationCycle_EXPIREONTRADINGSESSIONOPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExpirationCycle_EXPIREONTRADINGSESSIONOPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpirationCycle_EXPIREONTRADINGSESSIONOPEN));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 ExpirationCycle_EXPIREONTRADINGSESSIONCLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpirationCycle_EXPIREONTRADINGSESSIONCLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExpirationCycle_EXPIREONTRADINGSESSIONCLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpirationCycle_EXPIREONTRADINGSESSIONCLOSE));
  return pyobj;
}


SWIGINTERN int AllocCancReplaceReason_ORIGINALDETAILSINCORRECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocCancReplaceReason_ORIGINALDETAILSINCORRECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocCancReplaceReason_ORIGINALDETAILSINCORRECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocCancReplaceReason_ORIGINALDETAILSINCORRECT));
  return pyobj;
}


SWIGINTERN int 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 *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 AllocCancReplaceReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocCancReplaceReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocCancReplaceReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocCancReplaceReason_OTHER));
  return pyobj;
}


SWIGINTERN int AllocCancReplaceReason_ORIGINAL_DETAILS_INCOMPLETE_INCORRECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocCancReplaceReason_ORIGINAL_DETAILS_INCOMPLETE_INCORRECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 AllocCancReplaceReason_CHANGEINUNDERLYINGORDERDETAILS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocCancReplaceReason_CHANGEINUNDERLYINGORDERDETAILS is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocCancReplaceReason_CHANGEINUNDERLYINGORDERDETAILS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocCancReplaceReason_CHANGEINUNDERLYINGORDERDETAILS));
  return pyobj;
}


SWIGINTERN int CxlRejReason_DUPLICATE_CLORDID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_DUPLICATE_CLORDID is read-only.");
  return 1;
}


SWIGINTERN PyObject *CxlRejReason_DUPLICATE_CLORDID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_DUPLICATE_CLORDID));
  return pyobj;
}


SWIGINTERN int CxlRejReason_UNABLETOPROCESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_UNABLETOPROCESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *CxlRejReason_UNABLETOPROCESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_UNABLETOPROCESS));
  return pyobj;
}


SWIGINTERN int CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 CxlRejReason_DUPCLORDID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_DUPCLORDID is read-only.");
  return 1;
}


SWIGINTERN PyObject *CxlRejReason_DUPCLORDID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_DUPCLORDID));
  return pyobj;
}


SWIGINTERN int CxlRejReason_DUPLICATE_CLORDID_RECEIVED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_DUPLICATE_CLORDID_RECEIVED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 CxlRejReason_UNKNOWN_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_UNKNOWN_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *CxlRejReason_UNKNOWN_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_UNKNOWN_ORDER));
  return pyobj;
}


SWIGINTERN int CxlRejReason_TOO_LATE_TO_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_TOO_LATE_TO_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 CxlRejReason_TOOLATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_TOOLATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *CxlRejReason_TOOLATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_TOOLATE));
  return pyobj;
}


SWIGINTERN int CxlRejReason_ORIGORDMODTIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_ORIGORDMODTIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *CxlRejReason_ORIGORDMODTIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_ORIGORDMODTIME));
  return pyobj;
}


SWIGINTERN int CxlRejReason_INVALID_PRICE_INCREMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_INVALID_PRICE_INCREMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 CxlRejReason_BROKEROPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_BROKEROPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *CxlRejReason_BROKEROPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_BROKEROPT));
  return pyobj;
}


SWIGINTERN int CxlRejReason_ALREADYPENDINGCXL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_ALREADYPENDINGCXL is read-only.");
  return 1;
}


SWIGINTERN PyObject *CxlRejReason_ALREADYPENDINGCXL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_ALREADYPENDINGCXL));
  return pyobj;
}


SWIGINTERN int CxlRejReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *CxlRejReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_OTHER));
  return pyobj;
}


SWIGINTERN int CxlRejReason_BROKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_BROKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *CxlRejReason_BROKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_BROKER));
  return pyobj;
}


SWIGINTERN int CxlRejReason_BROKER_OPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_BROKER_OPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *CxlRejReason_BROKER_OPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_BROKER_OPTION));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 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 *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 CxlRejReason_ORIGORDMODTIMEMISMATCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_ORIGORDMODTIMEMISMATCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *CxlRejReason_ORIGORDMODTIMEMISMATCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_ORIGORDMODTIMEMISMATCH));
  return pyobj;
}


SWIGINTERN int 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 *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 CxlRejReason_UNKNOWN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_UNKNOWN is read-only.");
  return 1;
}


SWIGINTERN PyObject *CxlRejReason_UNKNOWN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_UNKNOWN));
  return pyobj;
}


SWIGINTERN int RespondentType_SPECIFIED_MARKET_PARTICIPANTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RespondentType_SPECIFIED_MARKET_PARTICIPANTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 RespondentType_ALL_MARKET_MAKERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RespondentType_ALL_MARKET_MAKERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 RespondentType_ALL_MARKET_PARTICIPANTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RespondentType_ALL_MARKET_PARTICIPANTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 RespondentType_PRIMARY_MARKET_MAKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RespondentType_PRIMARY_MARKET_MAKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 DKReason_NO_MATCHING_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DKReason_NO_MATCHING_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 DKReason_UNKNOWNSYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DKReason_UNKNOWNSYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *DKReason_UNKNOWNSYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DKReason_UNKNOWNSYMBOL));
  return pyobj;
}


SWIGINTERN int DKReason_PRICE_EXCEEDS_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DKReason_PRICE_EXCEEDS_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 DKReason_QUANTITYEXCEEDSORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DKReason_QUANTITYEXCEEDSORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *DKReason_QUANTITYEXCEEDSORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DKReason_QUANTITYEXCEEDSORDER));
  return pyobj;
}


SWIGINTERN int DKReason_QUANTITY_EXCEEDS_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DKReason_QUANTITY_EXCEEDS_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 DKReason_UNKNOWN_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DKReason_UNKNOWN_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *DKReason_UNKNOWN_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DKReason_UNKNOWN_SYMBOL));
  return pyobj;
}


SWIGINTERN int DKReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DKReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *DKReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DKReason_OTHER));
  return pyobj;
}


SWIGINTERN int DKReason_WRONGSIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DKReason_WRONGSIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *DKReason_WRONGSIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DKReason_WRONGSIDE));
  return pyobj;
}


SWIGINTERN int DKReason_CALCULATIONDIFFERENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DKReason_CALCULATIONDIFFERENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *DKReason_CALCULATIONDIFFERENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DKReason_CALCULATIONDIFFERENCE));
  return pyobj;
}


SWIGINTERN int DKReason_PRICEEXCEEDSLIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DKReason_PRICEEXCEEDSLIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *DKReason_PRICEEXCEEDSLIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DKReason_PRICEEXCEEDSLIMIT));
  return pyobj;
}


SWIGINTERN int DKReason_WRONG_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DKReason_WRONG_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *DKReason_WRONG_SIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DKReason_WRONG_SIDE));
  return pyobj;
}


SWIGINTERN int DKReason_CALCULATION_DIFFERENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DKReason_CALCULATION_DIFFERENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *DKReason_CALCULATION_DIFFERENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DKReason_CALCULATION_DIFFERENCE));
  return pyobj;
}


SWIGINTERN int DKReason_NOMATCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DKReason_NOMATCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *DKReason_NOMATCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DKReason_NOMATCH));
  return pyobj;
}


SWIGINTERN int PositionEffect_DEFAULT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PositionEffect_DEFAULT is read-only.");
  return 1;
}


SWIGINTERN PyObject *PositionEffect_DEFAULT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PositionEffect_DEFAULT));
  return pyobj;
}


SWIGINTERN int PositionEffect_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PositionEffect_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PositionEffect_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PositionEffect_CLOSE));
  return pyobj;
}


SWIGINTERN int 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 *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 PositionEffect_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PositionEffect_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *PositionEffect_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PositionEffect_OPEN));
  return pyobj;
}


SWIGINTERN int PositionEffect_FIFO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PositionEffect_FIFO is read-only.");
  return 1;
}


SWIGINTERN PyObject *PositionEffect_FIFO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PositionEffect_FIFO));
  return pyobj;
}


SWIGINTERN int PositionEffect_ROLLED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PositionEffect_ROLLED is read-only.");
  return 1;
}


SWIGINTERN PyObject *PositionEffect_ROLLED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PositionEffect_ROLLED));
  return pyobj;
}


SWIGINTERN int TriggerAction_ACTIVATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerAction_ACTIVATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TriggerAction_ACTIVATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerAction_ACTIVATE));
  return pyobj;
}


SWIGINTERN int TriggerAction_MODIFY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerAction_MODIFY is read-only.");
  return 1;
}


SWIGINTERN PyObject *TriggerAction_MODIFY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerAction_MODIFY));
  return pyobj;
}


SWIGINTERN int TriggerAction_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerAction_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *TriggerAction_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerAction_CANCEL));
  return pyobj;
}


SWIGINTERN int ClearingInstruction_BILATERALNETTINGONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_BILATERALNETTINGONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *ClearingInstruction_BILATERALNETTINGONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_BILATERALNETTINGONLY));
  return pyobj;
}


SWIGINTERN int ClearingInstruction_SPECIALTRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_SPECIALTRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ClearingInstruction_SPECIALTRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_SPECIALTRADE));
  return pyobj;
}


SWIGINTERN int ClearingInstruction_EXCLUDE_FROM_ALL_NETTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_EXCLUDE_FROM_ALL_NETTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ClearingInstruction_AUTOMATIC_POSTING_MODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_AUTOMATIC_POSTING_MODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ClearingInstruction_EXCLEARING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_EXCLEARING is read-only.");
  return 1;
}


SWIGINTERN PyObject *ClearingInstruction_EXCLEARING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_EXCLEARING));
  return pyobj;
}


SWIGINTERN int ClearingInstruction_MULTILATERAL_NETTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_MULTILATERAL_NETTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *ClearingInstruction_MULTILATERAL_NETTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_MULTILATERAL_NETTING));
  return pyobj;
}


SWIGINTERN int ClearingInstruction_CLEARAGAINSTCENTRALCOUNTERPARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_CLEARAGAINSTCENTRALCOUNTERPARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *ClearingInstruction_CLEARAGAINSTCENTRALCOUNTERPARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_CLEARAGAINSTCENTRALCOUNTERPARTY));
  return pyobj;
}


SWIGINTERN int ClearingInstruction_EXCLUDE_FROM_CENTRAL_COUNTERPARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_EXCLUDE_FROM_CENTRAL_COUNTERPARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ClearingInstruction_AUTOMATIC_GIVE_UP_MODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_AUTOMATIC_GIVE_UP_MODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ClearingInstruction_CUSTOMER_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_CUSTOMER_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ClearingInstruction_CUSTOMER_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_CUSTOMER_TRADE));
  return pyobj;
}


SWIGINTERN int ClearingInstruction_AUTOMATICPOSTINGMODETRADEPOSTINGTOTHEPOSITIONACCOUNTNUMBERSPECIFIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_AUTOMATICPOSTINGMODETRADEPOSTINGTOTHEPOSITIONACCOUNTNUMBERSPECIFIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *ClearingInstruction_AUTOMATICPOSTINGMODETRADEPOSTINGTOTHEPOSITIONACCOUNTNUMBERSPECIFIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_AUTOMATICPOSTINGMODETRADEPOSTINGTOTHEPOSITIONACCOUNTNUMBERSPECIFIED));
  return pyobj;
}


SWIGINTERN int ClearingInstruction_EX_CLEARING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_EX_CLEARING is read-only.");
  return 1;
}


SWIGINTERN PyObject *ClearingInstruction_EX_CLEARING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_EX_CLEARING));
  return pyobj;
}


SWIGINTERN int ClearingInstruction_QUALIFIEDSERVICEREPRESENTATIVEQSR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_QUALIFIEDSERVICEREPRESENTATIVEQSR is read-only.");
  return 1;
}


SWIGINTERN PyObject *ClearingInstruction_QUALIFIEDSERVICEREPRESENTATIVEQSR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_QUALIFIEDSERVICEREPRESENTATIVEQSR));
  return pyobj;
}


SWIGINTERN int ClearingInstruction_MULTILATERALNETTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_MULTILATERALNETTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *ClearingInstruction_MULTILATERALNETTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_MULTILATERALNETTING));
  return pyobj;
}


SWIGINTERN int ClearingInstruction_PROCESSNORMALLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_PROCESSNORMALLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *ClearingInstruction_PROCESSNORMALLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_PROCESSNORMALLY));
  return pyobj;
}


SWIGINTERN int ClearingInstruction_EXCLUDEFROMALLNETTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_EXCLUDEFROMALLNETTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *ClearingInstruction_EXCLUDEFROMALLNETTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_EXCLUDEFROMALLNETTING));
  return pyobj;
}


SWIGINTERN int ClearingInstruction_SELFCLEARING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_SELFCLEARING is read-only.");
  return 1;
}


SWIGINTERN PyObject *ClearingInstruction_SELFCLEARING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_SELFCLEARING));
  return pyobj;
}


SWIGINTERN int ClearingInstruction_CLEAR_AGAINST_CENTRAL_COUNTERPARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_CLEAR_AGAINST_CENTRAL_COUNTERPARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ClearingInstruction_BILATERAL_NETTING_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_BILATERAL_NETTING_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ClearingInstruction_EXCLUDEFROMCENTRALCOUNTERPARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_EXCLUDEFROMCENTRALCOUNTERPARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *ClearingInstruction_EXCLUDEFROMCENTRALCOUNTERPARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_EXCLUDEFROMCENTRALCOUNTERPARTY));
  return pyobj;
}


SWIGINTERN int ClearingInstruction_MANUALMODEPREPOSTINGANDORPREGIVEUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_MANUALMODEPREPOSTINGANDORPREGIVEUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *ClearingInstruction_MANUALMODEPREPOSTINGANDORPREGIVEUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_MANUALMODEPREPOSTINGANDORPREGIVEUP));
  return pyobj;
}


SWIGINTERN int ClearingInstruction_CUSTOMERTRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_CUSTOMERTRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ClearingInstruction_CUSTOMERTRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_CUSTOMERTRADE));
  return pyobj;
}


SWIGINTERN int ClearingInstruction_PROCESS_NORMALLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_PROCESS_NORMALLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *ClearingInstruction_PROCESS_NORMALLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_PROCESS_NORMALLY));
  return pyobj;
}


SWIGINTERN int ClearingInstruction_SPECIAL_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_SPECIAL_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ClearingInstruction_SPECIAL_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_SPECIAL_TRADE));
  return pyobj;
}


SWIGINTERN int ClearingInstruction_MANUAL_MODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_MANUAL_MODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ClearingInstruction_MANUAL_MODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_MANUAL_MODE));
  return pyobj;
}


SWIGINTERN int ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE_QSR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE_QSR is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ClearingInstruction_AUTOMATICGIVEUPMODETRADEGIVEUPTOTHEGIVEUPDESTINATIONNUMBERSPECIFIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_AUTOMATICGIVEUPMODETRADEGIVEUPTOTHEGIVEUPDESTINATIONNUMBERSPECIFIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *ClearingInstruction_AUTOMATICGIVEUPMODETRADEGIVEUPTOTHEGIVEUPDESTINATIONNUMBERSPECIFIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_AUTOMATICGIVEUPMODETRADEGIVEUPTOTHEGIVEUPDESTINATIONNUMBERSPECIFIED));
  return pyobj;
}


SWIGINTERN int ClearingInstruction_SELF_CLEARING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_SELF_CLEARING is read-only.");
  return 1;
}


SWIGINTERN PyObject *ClearingInstruction_SELF_CLEARING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_SELF_CLEARING));
  return pyobj;
}


SWIGINTERN int OpenCloseSettlFlag_SESSION_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettlFlag_SESSION_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *OpenCloseSettlFlag_SESSION_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_SESSION_OPEN));
  return pyobj;
}


SWIGINTERN int OpenCloseSettlFlag_EXPECTED_ENTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettlFlag_EXPECTED_ENTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *OpenCloseSettlFlag_EXPECTED_ENTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_EXPECTED_ENTRY));
  return pyobj;
}


SWIGINTERN int OpenCloseSettlFlag_THEORETICALPRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettlFlag_THEORETICALPRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *OpenCloseSettlFlag_THEORETICALPRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_THEORETICALPRICE));
  return pyobj;
}


SWIGINTERN int OpenCloseSettlFlag_ENTRYFROMPREVBUSINESSDAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettlFlag_ENTRYFROMPREVBUSINESSDAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *OpenCloseSettlFlag_ENTRYFROMPREVBUSINESSDAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_ENTRYFROMPREVBUSINESSDAY));
  return pyobj;
}


SWIGINTERN int OpenCloseSettlFlag_DAILY_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettlFlag_DAILY_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *OpenCloseSettlFlag_DAILY_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_DAILY_OPEN));
  return pyobj;
}


SWIGINTERN int OpenCloseSettlFlag_DAILYOPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettlFlag_DAILYOPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *OpenCloseSettlFlag_DAILYOPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_DAILYOPEN));
  return pyobj;
}


SWIGINTERN int OpenCloseSettlFlag_THEORETICAL_PRICE_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettlFlag_THEORETICAL_PRICE_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 OpenCloseSettlFlag_DELIVERY_SETTLEMENT_ENTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettlFlag_DELIVERY_SETTLEMENT_ENTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 OpenCloseSettlFlag_DELIVERYSETTLEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettlFlag_DELIVERYSETTLEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *OpenCloseSettlFlag_DELIVERYSETTLEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_DELIVERYSETTLEMENT));
  return pyobj;
}


SWIGINTERN int OpenCloseSettlFlag_SESSIONOPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettlFlag_SESSIONOPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *OpenCloseSettlFlag_SESSIONOPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_SESSIONOPEN));
  return pyobj;
}


SWIGINTERN int OpenCloseSettlFlag_EXPECTEDENTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettlFlag_EXPECTEDENTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *OpenCloseSettlFlag_EXPECTEDENTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_EXPECTEDENTRY));
  return pyobj;
}


SWIGINTERN int DiscretionMoveType_FLOATING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionMoveType_FLOATING is read-only.");
  return 1;
}


SWIGINTERN PyObject *DiscretionMoveType_FLOATING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionMoveType_FLOATING));
  return pyobj;
}


SWIGINTERN int DiscretionMoveType_FIXED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionMoveType_FIXED is read-only.");
  return 1;
}


SWIGINTERN PyObject *DiscretionMoveType_FIXED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionMoveType_FIXED));
  return pyobj;
}


SWIGINTERN int MDUpdateType_INCREMENTAL_REFRESH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDUpdateType_INCREMENTAL_REFRESH is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDUpdateType_INCREMENTAL_REFRESH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDUpdateType_INCREMENTAL_REFRESH));
  return pyobj;
}


SWIGINTERN int MDUpdateType_FULL_REFRESH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDUpdateType_FULL_REFRESH is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDUpdateType_FULL_REFRESH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDUpdateType_FULL_REFRESH));
  return pyobj;
}


SWIGINTERN int MDUpdateType_FULL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDUpdateType_FULL is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDUpdateType_FULL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDUpdateType_FULL));
  return pyobj;
}


SWIGINTERN int MDUpdateType_INCREMENTAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDUpdateType_INCREMENTAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDUpdateType_INCREMENTAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDUpdateType_INCREMENTAL));
  return pyobj;
}


SWIGINTERN int TickDirection_MINUS_TICK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickDirection_MINUS_TICK is read-only.");
  return 1;
}


SWIGINTERN PyObject *TickDirection_MINUS_TICK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TickDirection_MINUS_TICK));
  return pyobj;
}


SWIGINTERN int TickDirection_ZERO_PLUS_TICK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickDirection_ZERO_PLUS_TICK is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TickDirection_ZERO_MINUS_TICK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickDirection_ZERO_MINUS_TICK is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TickDirection_PLUS_TICK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickDirection_PLUS_TICK is read-only.");
  return 1;
}


SWIGINTERN PyObject *TickDirection_PLUS_TICK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TickDirection_PLUS_TICK));
  return pyobj;
}


SWIGINTERN int TickDirection_PLUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickDirection_PLUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TickDirection_PLUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TickDirection_PLUS));
  return pyobj;
}


SWIGINTERN int TickDirection_ZEROPLUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickDirection_ZEROPLUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TickDirection_ZEROPLUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TickDirection_ZEROPLUS));
  return pyobj;
}


SWIGINTERN int TickDirection_MINUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickDirection_MINUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TickDirection_MINUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TickDirection_MINUS));
  return pyobj;
}


SWIGINTERN int TickDirection_ZEROMINUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickDirection_ZEROMINUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TickDirection_ZEROMINUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TickDirection_ZEROMINUS));
  return pyobj;
}


SWIGINTERN int YieldType_MARK_TO_MARKET_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_MARK_TO_MARKET_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_MARK_TO_MARKET_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_MARK_TO_MARKET_YIELD);
  return pyobj;
}


SWIGINTERN int 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 *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 YieldType_YIELD_TO_MATURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_MATURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_YIELD_TO_MATURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_MATURITY);
  return pyobj;
}


SWIGINTERN int YieldType_YIELDTOTENDERDATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELDTOTENDERDATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_YIELDTOTENDERDATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELDTOTENDERDATE);
  return pyobj;
}


SWIGINTERN int YieldType_PREVIOUS_CLOSE_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_PREVIOUS_CLOSE_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_PREVIOUS_CLOSE_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_PREVIOUS_CLOSE_YIELD);
  return pyobj;
}


SWIGINTERN int 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 *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 YieldType_YIELDTOSHORTESTAVERAGELIFE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELDTOSHORTESTAVERAGELIFE is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_YIELDTOSHORTESTAVERAGELIFE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELDTOSHORTESTAVERAGELIFE);
  return pyobj;
}


SWIGINTERN int YieldType_YIELD_AT_ISSUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_AT_ISSUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_YIELD_AT_ISSUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_AT_ISSUE);
  return pyobj;
}


SWIGINTERN int YieldType_YIELD_TO_NEXT_REFUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_NEXT_REFUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_YIELD_TO_NEXT_REFUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_NEXT_REFUND);
  return pyobj;
}


SWIGINTERN int YieldType_YIELDATISSUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELDATISSUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_YIELDATISSUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELDATISSUE);
  return pyobj;
}


SWIGINTERN int YieldType_CLOSINGYIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_CLOSINGYIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_CLOSINGYIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_CLOSINGYIELD);
  return pyobj;
}


SWIGINTERN int YieldType_GVNTEQUIVALENTYIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_GVNTEQUIVALENTYIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_GVNTEQUIVALENTYIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_GVNTEQUIVALENTYIELD);
  return pyobj;
}


SWIGINTERN int YieldType_ANNUALYIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_ANNUALYIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_ANNUALYIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_ANNUALYIELD);
  return pyobj;
}


SWIGINTERN int YieldType_AFTER_TAX_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_AFTER_TAX_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_AFTER_TAX_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_AFTER_TAX_YIELD);
  return pyobj;
}


SWIGINTERN int YieldType_GVNT_EQUIVALENT_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_GVNT_EQUIVALENT_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_GVNT_EQUIVALENT_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_GVNT_EQUIVALENT_YIELD);
  return pyobj;
}


SWIGINTERN int YieldType_YIELDCHANGESINCECLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELDCHANGESINCECLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_YIELDCHANGESINCECLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELDCHANGESINCECLOSE);
  return pyobj;
}


SWIGINTERN int YieldType_YIELDTOMATURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELDTOMATURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_YIELDTOMATURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELDTOMATURITY);
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 YieldType_SEMI_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_SEMI is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_SEMI_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_SEMI);
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 YieldType_YIELD_TO_NEXT_CALL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_NEXT_CALL is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_YIELD_TO_NEXT_CALL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_NEXT_CALL);
  return pyobj;
}


SWIGINTERN int YieldType_YIELD_CHANGE_SINCE_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_CHANGE_SINCE_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_YIELD_CHANGE_SINCE_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_CHANGE_SINCE_CLOSE);
  return pyobj;
}


SWIGINTERN int YieldType_PROCEEDS_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_PROCEEDS_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_PROCEEDS_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_PROCEEDS_YIELD);
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 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 *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 YieldType_CURRENT_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_CURRENT_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_CURRENT_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_CURRENT_YIELD);
  return pyobj;
}


SWIGINTERN int YieldType_SIMPLEYIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_SIMPLEYIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_SIMPLEYIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_SIMPLEYIELD);
  return pyobj;
}


SWIGINTERN int YieldType_TRUEGROSSYIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_TRUEGROSSYIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_TRUEGROSSYIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_TRUEGROSSYIELD);
  return pyobj;
}


SWIGINTERN int YieldType_COMPOUND_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_COMPOUND_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_COMPOUND_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_COMPOUND_YIELD);
  return pyobj;
}


SWIGINTERN int YieldType_CLOSINGYIELDMOSTRECENTYEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_CLOSINGYIELDMOSTRECENTYEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_CLOSINGYIELDMOSTRECENTYEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_CLOSINGYIELDMOSTRECENTYEAR);
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 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 *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 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 *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 YieldType_YIELD_TO_AVG_MATURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_AVG_MATURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_YIELD_TO_AVG_MATURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_AVG_MATURITY);
  return pyobj;
}


SWIGINTERN int YieldType_YIELD_TO_TENDER_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_TENDER_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_YIELD_TO_TENDER_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_TENDER_DATE);
  return pyobj;
}


SWIGINTERN int YieldType_PROCEEDSYIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_PROCEEDSYIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_PROCEEDSYIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_PROCEEDSYIELD);
  return pyobj;
}


SWIGINTERN int 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 *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 YieldType_ANNUAL_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_ANNUAL_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_ANNUAL_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_ANNUAL_YIELD);
  return pyobj;
}


SWIGINTERN int YieldType_YIELD_TO_WORST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_WORST is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_YIELD_TO_WORST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_WORST);
  return pyobj;
}


SWIGINTERN int YieldType_BOOK_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_BOOK_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_BOOK_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_BOOK_YIELD);
  return pyobj;
}


SWIGINTERN int YieldType_YIELD_TO_NEXT_PUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_NEXT_PUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_YIELD_TO_NEXT_PUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_NEXT_PUT);
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 YieldType_OPENAVERAGEYIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_OPENAVERAGEYIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_OPENAVERAGEYIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_OPENAVERAGEYIELD);
  return pyobj;
}


SWIGINTERN int YieldType_TRUE_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_TRUE_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_TRUE_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_TRUE_YIELD);
  return pyobj;
}


SWIGINTERN int YieldType_TAX_EQUIVALENT_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_TAX_EQUIVALENT_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_TAX_EQUIVALENT_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_TAX_EQUIVALENT_YIELD);
  return pyobj;
}


SWIGINTERN int YieldType_TRUE_GROSS_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_TRUE_GROSS_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_TRUE_GROSS_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_TRUE_GROSS_YIELD);
  return pyobj;
}


SWIGINTERN int YieldType_INVERSE_FLOATER_BOND_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_INVERSE_FLOATER_BOND_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_INVERSE_FLOATER_BOND_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_INVERSE_FLOATER_BOND_YIELD);
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 YieldType_AFTERTAXYIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_AFTERTAXYIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_AFTERTAXYIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_AFTERTAXYIELD);
  return pyobj;
}


SWIGINTERN int 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 *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 YieldType_YIELDTOWORSTCONVENTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELDTOWORSTCONVENTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_YIELDTOWORSTCONVENTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELDTOWORSTCONVENTION);
  return pyobj;
}


SWIGINTERN int 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 *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 YieldType_COMPOUNDYIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_COMPOUNDYIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_COMPOUNDYIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_COMPOUNDYIELD);
  return pyobj;
}


SWIGINTERN int 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 *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 YieldType_YIELD_TO_LONGEST_AVERAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_LONGEST_AVERAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_YIELD_TO_LONGEST_AVERAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_LONGEST_AVERAGE);
  return pyobj;
}


SWIGINTERN int YieldType_PREVIOUSCLOSEYIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_PREVIOUSCLOSEYIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_PREVIOUSCLOSEYIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_PREVIOUSCLOSEYIELD);
  return pyobj;
}


SWIGINTERN int YieldType_CLOSINGYIELDMOSTRECENTMONTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_CLOSINGYIELDMOSTRECENTMONTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_CLOSINGYIELDMOSTRECENTMONTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_CLOSINGYIELDMOSTRECENTMONTH);
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 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 *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 YieldType_YIELD_TO_SHORTEST_AVERAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_SHORTEST_AVERAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_YIELD_TO_SHORTEST_AVERAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_SHORTEST_AVERAGE);
  return pyobj;
}


SWIGINTERN int YieldType_TAXEQUIVALENTYIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_TAXEQUIVALENTYIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_TAXEQUIVALENTYIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_TAXEQUIVALENTYIELD);
  return pyobj;
}


SWIGINTERN int YieldType_MOSTRECENTCLOSINGYIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_MOSTRECENTCLOSINGYIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_MOSTRECENTCLOSINGYIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_MOSTRECENTCLOSINGYIELD);
  return pyobj;
}


SWIGINTERN int YieldType_MARKTOMARKETYIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_MARKTOMARKETYIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_MARKTOMARKETYIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_MARKTOMARKETYIELD);
  return pyobj;
}


SWIGINTERN int YieldType_CURRENTYIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_CURRENTYIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_CURRENTYIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_CURRENTYIELD);
  return pyobj;
}


SWIGINTERN int YieldType_OPEN_AVERAGE_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_OPEN_AVERAGE_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_OPEN_AVERAGE_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_OPEN_AVERAGE_YIELD);
  return pyobj;
}


SWIGINTERN int 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 *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 YieldType_YIELD_WITH_INFLATION_ASSUMPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_WITH_INFLATION_ASSUMPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_YIELD_WITH_INFLATION_ASSUMPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_WITH_INFLATION_ASSUMPTION);
  return pyobj;
}


SWIGINTERN int YieldType_YIELDTONEXTREFUNDSINKING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELDTONEXTREFUNDSINKING is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_YIELDTONEXTREFUNDSINKING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELDTONEXTREFUNDSINKING);
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 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 *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 YieldType_SIMPLE_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_SIMPLE_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_SIMPLE_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_SIMPLE_YIELD);
  return pyobj;
}


SWIGINTERN int YieldType_YIELD_TO_AVERAGE_MATURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_AVERAGE_MATURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_YIELD_TO_AVERAGE_MATURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_AVERAGE_MATURITY);
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 YieldType_YIELDTOAVGMATURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELDTOAVGMATURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_YIELDTOAVGMATURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELDTOAVGMATURITY);
  return pyobj;
}


SWIGINTERN int YieldType_YIELDTOLONGESTAVERAGELIFE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELDTOLONGESTAVERAGELIFE is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_YIELDTOLONGESTAVERAGELIFE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELDTOLONGESTAVERAGELIFE);
  return pyobj;
}


SWIGINTERN int 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 *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 YieldType_SEMI_ANNUAL_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_SEMI_ANNUAL_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_SEMI_ANNUAL_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_SEMI_ANNUAL_YIELD);
  return pyobj;
}


SWIGINTERN int YieldType_MOST_RECENT_CLOSING_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_MOST_RECENT_CLOSING_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_MOST_RECENT_CLOSING_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_MOST_RECENT_CLOSING_YIELD);
  return pyobj;
}


SWIGINTERN int 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 *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 YieldType_CLOSING_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_CLOSING_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_CLOSING_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_CLOSING_YIELD);
  return pyobj;
}


SWIGINTERN int YieldType_YIELDINFLATIONASSUMPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELDINFLATIONASSUMPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_YIELDINFLATIONASSUMPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELDINFLATIONASSUMPTION);
  return pyobj;
}


SWIGINTERN int 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 *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 YieldType_TRUEYIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_TRUEYIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_TRUEYIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_TRUEYIELD);
  return pyobj;
}


SWIGINTERN int YieldType_CLOSINGYIELDMOSTRECENTQUARTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_CLOSINGYIELDMOSTRECENTQUARTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_CLOSINGYIELDMOSTRECENTQUARTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_CLOSINGYIELDMOSTRECENTQUARTER);
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 YieldType_INVFLOATERBONDYIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_INVFLOATERBONDYIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_INVFLOATERBONDYIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_INVFLOATERBONDYIELD);
  return pyobj;
}


SWIGINTERN int 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 *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 YieldType_YIELDTONEXTPUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELDTONEXTPUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_YIELDTONEXTPUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELDTONEXTPUT);
  return pyobj;
}


SWIGINTERN int YieldType_YIELDTONEXTCALL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELDTONEXTCALL is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_YIELDTONEXTCALL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELDTONEXTCALL);
  return pyobj;
}


SWIGINTERN int 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 *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 YieldType_BOOKYIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_BOOKYIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_BOOKYIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_BOOKYIELD);
  return pyobj;
}


SWIGINTERN int YieldType_YIELDVALUEOF132_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELDVALUEOF132 is read-only.");
  return 1;
}


SWIGINTERN PyObject *YieldType_YIELDVALUEOF132_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELDVALUEOF132);
  return pyobj;
}


SWIGINTERN int PegScope_NATIONAL_XXCLUDING_LOCAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegScope_NATIONAL_XXCLUDING_LOCAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PegScope_NATIONAL_EXCLUDING_LOCAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegScope_NATIONAL_EXCLUDING_LOCAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PegScope_LOCAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegScope_LOCAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *PegScope_LOCAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegScope_LOCAL));
  return pyobj;
}


SWIGINTERN int PegScope_NATIONALEXCLUDINGLOCAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegScope_NATIONALEXCLUDINGLOCAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *PegScope_NATIONALEXCLUDINGLOCAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegScope_NATIONALEXCLUDINGLOCAL));
  return pyobj;
}


SWIGINTERN int PegScope_GLOBAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegScope_GLOBAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *PegScope_GLOBAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegScope_GLOBAL));
  return pyobj;
}


SWIGINTERN int PegScope_NATIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegScope_NATIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *PegScope_NATIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegScope_NATIONAL));
  return pyobj;
}


SWIGINTERN int PegScope_LOCALEXCHANGEECNATS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegScope_LOCALEXCHANGEECNATS is read-only.");
  return 1;
}


SWIGINTERN PyObject *PegScope_LOCALEXCHANGEECNATS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegScope_LOCALEXCHANGEECNATS));
  return pyobj;
}


SWIGINTERN int SettlDeliveryType_TRI_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlDeliveryType_TRI_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlDeliveryType_TRI_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlDeliveryType_TRI_PARTY));
  return pyobj;
}


SWIGINTERN int SettlDeliveryType_HOLD_IN_CUSTODY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlDeliveryType_HOLD_IN_CUSTODY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SettlDeliveryType_FREE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlDeliveryType_FREE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlDeliveryType_FREE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlDeliveryType_FREE));
  return pyobj;
}


SWIGINTERN int SettlDeliveryType_VERSUS_PAYMENT_DELIVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlDeliveryType_VERSUS_PAYMENT_DELIVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SettlDeliveryType_FREE_DELIVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlDeliveryType_FREE_DELIVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlDeliveryType_FREE_DELIVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlDeliveryType_FREE_DELIVER));
  return pyobj;
}


SWIGINTERN int SettlDeliveryType_VERSUS_PAYMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlDeliveryType_VERSUS_PAYMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlDeliveryType_VERSUS_PAYMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlDeliveryType_VERSUS_PAYMENT));
  return pyobj;
}


SWIGINTERN int DiscretionLimitType_STRICT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionLimitType_STRICT is read-only.");
  return 1;
}


SWIGINTERN PyObject *DiscretionLimitType_STRICT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionLimitType_STRICT));
  return pyobj;
}


SWIGINTERN int DiscretionLimitType_ORWORSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionLimitType_ORWORSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *DiscretionLimitType_ORWORSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionLimitType_ORWORSE));
  return pyobj;
}


SWIGINTERN int DiscretionLimitType_OR_BETTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionLimitType_OR_BETTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *DiscretionLimitType_OR_BETTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionLimitType_OR_BETTER));
  return pyobj;
}


SWIGINTERN int DiscretionLimitType_OR_WORSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionLimitType_OR_WORSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *DiscretionLimitType_OR_WORSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionLimitType_OR_WORSE));
  return pyobj;
}


SWIGINTERN int DiscretionLimitType_ORBETTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionLimitType_ORBETTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *DiscretionLimitType_ORBETTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionLimitType_ORBETTER));
  return pyobj;
}


SWIGINTERN int PartyDetailsRequestResult_UNSUPPORTED_PARTYLISTRESPONSETYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailsRequestResult_UNSUPPORTED_PARTYLISTRESPONSETYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyDetailsRequestResult_UNSUPPORTED_PARTYLISTRESPONSETYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailsRequestResult_UNSUPPORTED_PARTYLISTRESPONSETYPE));
  return pyobj;
}


SWIGINTERN int PartyDetailsRequestResult_PARTIES_OR_PARTY_DETAILS_DATA_TEMPORARILY_UNAVAILABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailsRequestResult_PARTIES_OR_PARTY_DETAILS_DATA_TEMPORARILY_UNAVAILABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyDetailsRequestResult_PARTIES_OR_PARTY_DETAILS_DATA_TEMPORARILY_UNAVAILABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailsRequestResult_PARTIES_OR_PARTY_DETAILS_DATA_TEMPORARILY_UNAVAILABLE));
  return pyobj;
}


SWIGINTERN int PartyDetailsRequestResult_VALID_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailsRequestResult_VALID_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyDetailsRequestResult_VALID_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailsRequestResult_VALID_REQUEST));
  return pyobj;
}


SWIGINTERN int PartyDetailsRequestResult_REQUEST_FOR_PARTIES_DATA_NOT_SUPPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailsRequestResult_REQUEST_FOR_PARTIES_DATA_NOT_SUPPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyDetailsRequestResult_REQUEST_FOR_PARTIES_DATA_NOT_SUPPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailsRequestResult_REQUEST_FOR_PARTIES_DATA_NOT_SUPPORTED));
  return pyobj;
}


SWIGINTERN int PartyDetailsRequestResult_NO_PARTIES_OR_PARTY_DETAILS_FOUND_THAT_MATCH_SELECTION_CRITERIA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailsRequestResult_NO_PARTIES_OR_PARTY_DETAILS_FOUND_THAT_MATCH_SELECTION_CRITERIA is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyDetailsRequestResult_NO_PARTIES_OR_PARTY_DETAILS_FOUND_THAT_MATCH_SELECTION_CRITERIA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailsRequestResult_NO_PARTIES_OR_PARTY_DETAILS_FOUND_THAT_MATCH_SELECTION_CRITERIA));
  return pyobj;
}


SWIGINTERN int PartyDetailsRequestResult_INVALID_OR_UNSUPPORTED_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailsRequestResult_INVALID_OR_UNSUPPORTED_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyDetailsRequestResult_INVALID_OR_UNSUPPORTED_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailsRequestResult_INVALID_OR_UNSUPPORTED_REQUEST));
  return pyobj;
}


SWIGINTERN int PartyDetailsRequestResult_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailsRequestResult_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyDetailsRequestResult_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailsRequestResult_OTHER));
  return pyobj;
}


SWIGINTERN int PartyDetailsRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_PARTIES_OR_PARTY_DETAILS_DATA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyDetailsRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_PARTIES_OR_PARTY_DETAILS_DATA is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyDetailsRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_PARTIES_OR_PARTY_DETAILS_DATA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyDetailsRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_PARTIES_OR_PARTY_DETAILS_DATA));
  return pyobj;
}


SWIGINTERN int ExerciseMethod_AUTOMATIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExerciseMethod_AUTOMATIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExerciseMethod_AUTOMATIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExerciseMethod_AUTOMATIC));
  return pyobj;
}


SWIGINTERN int ExerciseMethod_MANUAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExerciseMethod_MANUAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExerciseMethod_MANUAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExerciseMethod_MANUAL));
  return pyobj;
}


SWIGINTERN int WorkingIndicator_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable WorkingIndicator_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *WorkingIndicator_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::WorkingIndicator_NO));
  return pyobj;
}


SWIGINTERN int WorkingIndicator_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable WorkingIndicator_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *WorkingIndicator_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::WorkingIndicator_YES));
  return pyobj;
}


SWIGINTERN int SideMultiLegReportingType_INDIVIDUALLEGOFAMULTILEGSECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideMultiLegReportingType_INDIVIDUALLEGOFAMULTILEGSECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SideMultiLegReportingType_INDIVIDUALLEGOFAMULTILEGSECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideMultiLegReportingType_INDIVIDUALLEGOFAMULTILEGSECURITY));
  return pyobj;
}


SWIGINTERN int SideMultiLegReportingType_SINGLE_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideMultiLegReportingType_SINGLE_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SideMultiLegReportingType_SINGLE_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideMultiLegReportingType_SINGLE_SECURITY));
  return pyobj;
}


SWIGINTERN int SideMultiLegReportingType_MULTILEG_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideMultiLegReportingType_MULTILEG_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SideMultiLegReportingType_MULTILEG_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideMultiLegReportingType_MULTILEG_SECURITY));
  return pyobj;
}


SWIGINTERN int 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 *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 SideMultiLegReportingType_MULTILEGSECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideMultiLegReportingType_MULTILEGSECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SideMultiLegReportingType_MULTILEGSECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideMultiLegReportingType_MULTILEGSECURITY));
  return pyobj;
}


SWIGINTERN int SideMultiLegReportingType_SINGLESECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideMultiLegReportingType_SINGLESECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SideMultiLegReportingType_SINGLESECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideMultiLegReportingType_SINGLESECURITY));
  return pyobj;
}


SWIGINTERN int ConfirmRejReason_MISSINGSETTLEMENTINSTRUCTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmRejReason_MISSINGSETTLEMENTINSTRUCTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *ConfirmRejReason_MISSINGSETTLEMENTINSTRUCTIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_MISSINGSETTLEMENTINSTRUCTIONS));
  return pyobj;
}


SWIGINTERN int ConfirmRejReason_MISSING_SETTLEMENT_INSTRUCTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmRejReason_MISSING_SETTLEMENT_INSTRUCTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ConfirmRejReason_MISMATCHEDACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmRejReason_MISMATCHEDACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ConfirmRejReason_MISMATCHEDACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_MISMATCHEDACCOUNT));
  return pyobj;
}


SWIGINTERN int ConfirmRejReason_MISMATCHED_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmRejReason_MISMATCHED_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ConfirmRejReason_MISMATCHED_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_MISMATCHED_ACCOUNT));
  return pyobj;
}


SWIGINTERN int ConfirmRejReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmRejReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *ConfirmRejReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_OTHER));
  return pyobj;
}


SWIGINTERN int BidRequestTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidRequestTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *BidRequestTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BidRequestTransType_NEW));
  return pyobj;
}


SWIGINTERN int BidRequestTransType_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidRequestTransType_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *BidRequestTransType_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BidRequestTransType_NO));
  return pyobj;
}


SWIGINTERN int BidRequestTransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidRequestTransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *BidRequestTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BidRequestTransType_CANCEL));
  return pyobj;
}


SWIGINTERN int MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 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 *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 MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MassActionRejectReason_INVALID_OR_UNKNOWN_CFICODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_INVALID_OR_UNKNOWN_CFICODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 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 *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 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 *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 MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MassActionRejectReason_MASS_ACTION_NOT_SUPPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_MASS_ACTION_NOT_SUPPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MassActionRejectReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassActionRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_OTHER));
  return pyobj;
}


SWIGINTERN int 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 *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 MassActionRejectReason_INVALID_OR_UNKNOWN_PRODUCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_INVALID_OR_UNKNOWN_PRODUCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 CollApplType_GENERAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollApplType_GENERAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollApplType_GENERAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollApplType_GENERAL));
  return pyobj;
}


SWIGINTERN int CollApplType_SPECIFIC_DEPOSIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollApplType_SPECIFIC_DEPOSIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollApplType_SPECIFIC_DEPOSIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollApplType_SPECIFIC_DEPOSIT));
  return pyobj;
}


SWIGINTERN int ConfirmType_CONFIRMATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmType_CONFIRMATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *ConfirmType_CONFIRMATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmType_CONFIRMATION));
  return pyobj;
}


SWIGINTERN int ConfirmType_CONFIRMATION_REQUEST_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmType_CONFIRMATION_REQUEST_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ConfirmType_CONFIRMATIONREQUESTREJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmType_CONFIRMATIONREQUESTREJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *ConfirmType_CONFIRMATIONREQUESTREJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmType_CONFIRMATIONREQUESTREJECTED));
  return pyobj;
}


SWIGINTERN int ConfirmType_STATUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmType_STATUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *ConfirmType_STATUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmType_STATUS));
  return pyobj;
}


SWIGINTERN int MDQuoteType_INDICATIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDQuoteType_INDICATIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDQuoteType_INDICATIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDQuoteType_INDICATIVE));
  return pyobj;
}


SWIGINTERN int MDQuoteType_RESTRICTED_TRADEABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDQuoteType_RESTRICTED_TRADEABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDQuoteType_RESTRICTED_TRADEABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDQuoteType_RESTRICTED_TRADEABLE));
  return pyobj;
}


SWIGINTERN int MDQuoteType_INDICATIVE_AND_TRADEABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDQuoteType_INDICATIVE_AND_TRADEABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MDQuoteType_TRADEABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDQuoteType_TRADEABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDQuoteType_TRADEABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDQuoteType_TRADEABLE));
  return pyobj;
}


SWIGINTERN int MDQuoteType_COUNTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDQuoteType_COUNTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDQuoteType_COUNTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDQuoteType_COUNTER));
  return pyobj;
}


SWIGINTERN int QtyType_CONTRACTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QtyType_CONTRACTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *QtyType_CONTRACTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QtyType_CONTRACTS));
  return pyobj;
}


SWIGINTERN int 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 *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 QtyType_UNITS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QtyType_UNITS is read-only.");
  return 1;
}


SWIGINTERN PyObject *QtyType_UNITS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QtyType_UNITS));
  return pyobj;
}


SWIGINTERN int QuoteRespType_END_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRespType_END_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRespType_END_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_END_TRADE));
  return pyobj;
}


SWIGINTERN int QuoteRespType_HITLIFT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRespType_HITLIFT is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRespType_HITLIFT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_HITLIFT));
  return pyobj;
}


SWIGINTERN int QuoteRespType_HIT_LIFT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRespType_HIT_LIFT is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRespType_HIT_LIFT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_HIT_LIFT));
  return pyobj;
}


SWIGINTERN int QuoteRespType_COVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRespType_COVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRespType_COVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_COVER));
  return pyobj;
}


SWIGINTERN int QuoteRespType_DONE_AWAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRespType_DONE_AWAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRespType_DONE_AWAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_DONE_AWAY));
  return pyobj;
}


SWIGINTERN int QuoteRespType_DONEAWAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRespType_DONEAWAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRespType_DONEAWAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_DONEAWAY));
  return pyobj;
}


SWIGINTERN int QuoteRespType_TIMED_OUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRespType_TIMED_OUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRespType_TIMED_OUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_TIMED_OUT));
  return pyobj;
}


SWIGINTERN int QuoteRespType_PASS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRespType_PASS is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRespType_PASS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_PASS));
  return pyobj;
}


SWIGINTERN int QuoteRespType_EXPIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRespType_EXPIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRespType_EXPIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_EXPIRED));
  return pyobj;
}


SWIGINTERN int QuoteRespType_COUNTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRespType_COUNTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRespType_COUNTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_COUNTER));
  return pyobj;
}


SWIGINTERN int IOINaturalFlag_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOINaturalFlag_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOINaturalFlag_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOINaturalFlag_NO));
  return pyobj;
}


SWIGINTERN int IOINaturalFlag_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOINaturalFlag_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOINaturalFlag_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOINaturalFlag_YES));
  return pyobj;
}


SWIGINTERN int SettlObligSource_INSTRUCTIONS_OF_BROKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlObligSource_INSTRUCTIONS_OF_BROKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SettlObligSource_INVESTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlObligSource_INVESTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlObligSource_INVESTOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlObligSource_INVESTOR));
  return pyobj;
}


SWIGINTERN int SettlObligSource_INSTRUCTIONS_FOR_INSTITUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlObligSource_INSTRUCTIONS_FOR_INSTITUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdSubType_ON_HOURS_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_ON_HOURS_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdSubType_INTERIM_PROTECTED_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_INTERIM_PROTECTED_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdSubType_K_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_K is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdSubType_K_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_K));
  return pyobj;
}


SWIGINTERN int TrdSubType_LC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_LC is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdSubType_LC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_LC));
  return pyobj;
}


SWIGINTERN int TrdSubType_WN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_WN is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdSubType_WN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_WN));
  return pyobj;
}


SWIGINTERN int TrdSubType_CONVERTED_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_CONVERTED_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdSubType_CONVERTED_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_CONVERTED_SWAP));
  return pyobj;
}


SWIGINTERN int TrdSubType_B_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_B is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdSubType_B_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_B));
  return pyobj;
}


SWIGINTERN int TrdSubType_M_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_M is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdSubType_M_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_M));
  return pyobj;
}


SWIGINTERN int TrdSubType_RT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_RT is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdSubType_RT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_RT));
  return pyobj;
}


SWIGINTERN int 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 *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 TrdSubType_CMTA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_CMTA is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdSubType_CMTA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_CMTA));
  return pyobj;
}


SWIGINTERN int TrdSubType_INTERNAL_TRANSFER_OR_ADJUSTMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_INTERNAL_TRANSFER_OR_ADJUSTMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdSubType_DIFFERENTIAL_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_DIFFERENTIAL_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdSubType_DIFFERENTIAL_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_DIFFERENTIAL_SPREAD));
  return pyobj;
}


SWIGINTERN int TrdSubType_TRANSACTION_FROM_EXERCISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_TRANSACTION_FROM_EXERCISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdSubType_TRANSACTION_FROM_ASSIGNMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_TRANSACTION_FROM_ASSIGNMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdSubType_N_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_N is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdSubType_N_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_N));
  return pyobj;
}


SWIGINTERN int 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 *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 TrdSubType_NR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_NR is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdSubType_NR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_NR));
  return pyobj;
}


SWIGINTERN int TrdSubType_SW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_SW is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdSubType_SW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_SW));
  return pyobj;
}


SWIGINTERN int TrdSubType_OTC_QUOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_OTC_QUOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdSubType_OTC_QUOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_OTC_QUOTE));
  return pyobj;
}


SWIGINTERN int TrdSubType_ADVISORY_FOR_CONTRA_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_ADVISORY_FOR_CONTRA_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 TrdSubType_P_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_P is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdSubType_P_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_P));
  return pyobj;
}


SWIGINTERN int TrdSubType_CROSSED_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_CROSSED_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdSubType_CROSSED_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_CROSSED_TRADE));
  return pyobj;
}


SWIGINTERN int TrdSubType_PA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_PA is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdSubType_PA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_PA));
  return pyobj;
}


SWIGINTERN int 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 *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 TrdSubType_R_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_R is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdSubType_R_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_R));
  return pyobj;
}


SWIGINTERN int TrdSubType_RO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_RO is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdSubType_RO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_RO));
  return pyobj;
}


SWIGINTERN int TrdSubType_WT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_WT is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdSubType_WT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_WT));
  return pyobj;
}


SWIGINTERN int TrdSubType_OFF_HOURS_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_OFF_HOURS_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdSubType_REJECT_FOR_SUBMITTING_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_REJECT_FOR_SUBMITTING_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 TrdSubType_AI_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_AI is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdSubType_AI_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_AI));
  return pyobj;
}


SWIGINTERN int TrdSubType_PC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_PC is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdSubType_PC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_PC));
  return pyobj;
}


SWIGINTERN int TrdSubType_PN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_PN is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdSubType_PN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_PN));
  return pyobj;
}


SWIGINTERN int TrdSubType_LARGE_IN_SCALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_LARGE_IN_SCALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdSubType_NM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_NM is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdSubType_NM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_NM));
  return pyobj;
}


SWIGINTERN int TrdSubType_T_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_T is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdSubType_T_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_T));
  return pyobj;
}


SWIGINTERN int TrdSubType_ACATS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_ACATS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdSubType_ACATS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_ACATS));
  return pyobj;
}


SWIGINTERN int ExecTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecTransType_NEW));
  return pyobj;
}


SWIGINTERN int ExecTransType_CORRECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecTransType_CORRECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecTransType_CORRECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecTransType_CORRECT));
  return pyobj;
}


SWIGINTERN int ExecTransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecTransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecTransType_CANCEL));
  return pyobj;
}


SWIGINTERN int ExecTransType_STATUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecTransType_STATUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecTransType_STATUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecTransType_STATUS));
  return pyobj;
}


SWIGINTERN int 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 *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 DayBookingInst_ACCUMULATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DayBookingInst_ACCUMULATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *DayBookingInst_ACCUMULATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DayBookingInst_ACCUMULATE));
  return pyobj;
}


SWIGINTERN int DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING_SPEAK_FIRST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING_SPEAK_FIRST is read-only.");
  return 1;
}


SWIGINTERN PyObject *DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING_SPEAK_FIRST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING_SPEAK_FIRST));
  return pyobj;
}


SWIGINTERN int DayBookingInst_CAN_TRIGGER_BOOKING_WITHOUT_REFERENCE_TO_THE_ORDER_INITIATOR_AUTO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DayBookingInst_CAN_TRIGGER_BOOKING_WITHOUT_REFERENCE_TO_THE_ORDER_INITIATOR_AUTO is read-only.");
  return 1;
}


SWIGINTERN PyObject *DayBookingInst_CAN_TRIGGER_BOOKING_WITHOUT_REFERENCE_TO_THE_ORDER_INITIATOR_AUTO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DayBookingInst_CAN_TRIGGER_BOOKING_WITHOUT_REFERENCE_TO_THE_ORDER_INITIATOR_AUTO));
  return pyobj;
}


SWIGINTERN int 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 *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 FlowScheduleType_NERC_EASTERN_OFF_PEAK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FlowScheduleType_NERC_EASTERN_OFF_PEAK is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 FlowScheduleType_NERC_WESTERN_PEAK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FlowScheduleType_NERC_WESTERN_PEAK is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 FlowScheduleType_NERC_EASTERN_PEAK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FlowScheduleType_NERC_EASTERN_PEAK is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 FlowScheduleType_NERC_WESTERN_OFF_PEAK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FlowScheduleType_NERC_WESTERN_OFF_PEAK is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MDOriginType_CROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDOriginType_CROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDOriginType_CROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDOriginType_CROSS));
  return pyobj;
}


SWIGINTERN int MDOriginType_OFF_BOOK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDOriginType_OFF_BOOK is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDOriginType_OFF_BOOK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDOriginType_OFF_BOOK));
  return pyobj;
}


SWIGINTERN int MDOriginType_BOOK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDOriginType_BOOK is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDOriginType_BOOK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDOriginType_BOOK));
  return pyobj;
}


SWIGINTERN int CollInquiryStatus_ACCEPTED_WITH_WARNINGS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryStatus_ACCEPTED_WITH_WARNINGS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 CollInquiryStatus_COMPLETED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryStatus_COMPLETED is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollInquiryStatus_COMPLETED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryStatus_COMPLETED));
  return pyobj;
}


SWIGINTERN int CollInquiryStatus_ACCEPTEDWITHWARNINGS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryStatus_ACCEPTEDWITHWARNINGS is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollInquiryStatus_ACCEPTEDWITHWARNINGS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryStatus_ACCEPTEDWITHWARNINGS));
  return pyobj;
}


SWIGINTERN int CollInquiryStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollInquiryStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int CollInquiryStatus_COMPLETEDWITHWARNINGS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryStatus_COMPLETEDWITHWARNINGS is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollInquiryStatus_COMPLETEDWITHWARNINGS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryStatus_COMPLETEDWITHWARNINGS));
  return pyobj;
}


SWIGINTERN int CollInquiryStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollInquiryStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int CollInquiryStatus_COMPLETED_WITH_WARNINGS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryStatus_COMPLETED_WITH_WARNINGS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 CPProgram_3A3_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CPProgram_3A3 is read-only.");
  return 1;
}


SWIGINTERN PyObject *CPProgram_3A3_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CPProgram_3A3));
  return pyobj;
}


SWIGINTERN int CPProgram_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CPProgram_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *CPProgram_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CPProgram_OTHER));
  return pyobj;
}


SWIGINTERN int CPProgram_3_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CPProgram_3 is read-only.");
  return 1;
}


SWIGINTERN PyObject *CPProgram_3_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CPProgram_3));
  return pyobj;
}


SWIGINTERN int CPProgram_42_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CPProgram_42 is read-only.");
  return 1;
}


SWIGINTERN PyObject *CPProgram_42_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CPProgram_42));
  return pyobj;
}


SWIGINTERN int CPProgram_4_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CPProgram_4 is read-only.");
  return 1;
}


SWIGINTERN PyObject *CPProgram_4_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CPProgram_4));
  return pyobj;
}


SWIGINTERN int PosReqType_POSITIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqType_POSITIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosReqType_POSITIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqType_POSITIONS));
  return pyobj;
}


SWIGINTERN int PosReqType_BACKOUT_MESSAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqType_BACKOUT_MESSAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosReqType_BACKOUT_MESSAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqType_BACKOUT_MESSAGE));
  return pyobj;
}


SWIGINTERN int PosReqType_DELTA_POSITIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqType_DELTA_POSITIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosReqType_DELTA_POSITIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqType_DELTA_POSITIONS));
  return pyobj;
}


SWIGINTERN int PosReqType_SETTLEMENT_ACTIVITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqType_SETTLEMENT_ACTIVITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosReqType_SETTLEMENT_ACTIVITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqType_SETTLEMENT_ACTIVITY));
  return pyobj;
}


SWIGINTERN int PosReqType_TRADES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqType_TRADES is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosReqType_TRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqType_TRADES));
  return pyobj;
}


SWIGINTERN int PosReqType_EXERCISES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqType_EXERCISES is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosReqType_EXERCISES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqType_EXERCISES));
  return pyobj;
}


SWIGINTERN int PosReqType_ASSIGNMENTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqType_ASSIGNMENTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosReqType_ASSIGNMENTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqType_ASSIGNMENTS));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 MassStatusReqType_STATUSSECURITYTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassStatusReqType_STATUSSECURITYTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassStatusReqType_STATUSSECURITYTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUSSECURITYTYPE));
  return pyobj;
}


SWIGINTERN int 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 *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 MassStatusReqType_STATUSTRDSESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassStatusReqType_STATUSTRDSESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassStatusReqType_STATUSTRDSESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUSTRDSESSION));
  return pyobj;
}


SWIGINTERN int 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 *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 MassStatusReqType_STATUS_FOR_SECURITY_ISSUER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassStatusReqType_STATUS_FOR_SECURITY_ISSUER is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MassStatusReqType_STATUSCFICODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassStatusReqType_STATUSCFICODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassStatusReqType_STATUSCFICODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUSCFICODE));
  return pyobj;
}


SWIGINTERN int 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 *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 MassStatusReqType_STATUSUNDERLYINGSECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassStatusReqType_STATUSUNDERLYINGSECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassStatusReqType_STATUSUNDERLYINGSECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUSUNDERLYINGSECURITY));
  return pyobj;
}


SWIGINTERN int MassStatusReqType_STATUSPARTYID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassStatusReqType_STATUSPARTYID is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassStatusReqType_STATUSPARTYID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUSPARTYID));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 MassStatusReqType_STATUS_FOR_ALL_ORDERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassStatusReqType_STATUS_FOR_ALL_ORDERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 MassStatusReqType_STATUSSECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassStatusReqType_STATUSSECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassStatusReqType_STATUSSECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUSSECURITY));
  return pyobj;
}


SWIGINTERN int MassStatusReqType_STATUSPRODUCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassStatusReqType_STATUSPRODUCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassStatusReqType_STATUSPRODUCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUSPRODUCT));
  return pyobj;
}


SWIGINTERN int MassStatusReqType_STATUSALLORDERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassStatusReqType_STATUSALLORDERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassStatusReqType_STATUSALLORDERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUSALLORDERS));
  return pyobj;
}


SWIGINTERN int 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 *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 SubscriptionRequestType_SNAPSHOT_PLUS_UPDATES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SubscriptionRequestType_SNAPSHOT_PLUS_UPDATES is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SubscriptionRequestType_SNAPSHOTUPDATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SubscriptionRequestType_SNAPSHOTUPDATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SubscriptionRequestType_SNAPSHOTUPDATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SubscriptionRequestType_SNAPSHOTUPDATE));
  return pyobj;
}


SWIGINTERN int SubscriptionRequestType_SNAPSHOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SubscriptionRequestType_SNAPSHOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SubscriptionRequestType_SNAPSHOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SubscriptionRequestType_SNAPSHOT));
  return pyobj;
}


SWIGINTERN int SubscriptionRequestType_UNSUBSCRIBE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SubscriptionRequestType_UNSUBSCRIBE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SubscriptionRequestType_UNSUBSCRIBE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SubscriptionRequestType_UNSUBSCRIBE));
  return pyobj;
}


SWIGINTERN int NewsCategory_MARKETPLACE_NEWS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NewsCategory_MARKETPLACE_NEWS is read-only.");
  return 1;
}


SWIGINTERN PyObject *NewsCategory_MARKETPLACE_NEWS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NewsCategory_MARKETPLACE_NEWS));
  return pyobj;
}


SWIGINTERN int NewsCategory_TECHNICAL_NEWS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NewsCategory_TECHNICAL_NEWS is read-only.");
  return 1;
}


SWIGINTERN PyObject *NewsCategory_TECHNICAL_NEWS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NewsCategory_TECHNICAL_NEWS));
  return pyobj;
}


SWIGINTERN int NewsCategory_COMPANY_NEWS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NewsCategory_COMPANY_NEWS is read-only.");
  return 1;
}


SWIGINTERN PyObject *NewsCategory_COMPANY_NEWS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NewsCategory_COMPANY_NEWS));
  return pyobj;
}


SWIGINTERN int NewsCategory_OTHER_NEWS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NewsCategory_OTHER_NEWS is read-only.");
  return 1;
}


SWIGINTERN PyObject *NewsCategory_OTHER_NEWS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NewsCategory_OTHER_NEWS));
  return pyobj;
}


SWIGINTERN int NewsCategory_FINANCIAL_MARKET_NEWS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NewsCategory_FINANCIAL_MARKET_NEWS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 IOIQty_MEDIUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQty_MEDIUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIQty_MEDIUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IOIQty_MEDIUM);
  return pyobj;
}


SWIGINTERN int IOIQty_1000000000_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQty_1000000000 is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIQty_1000000000_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IOIQty_1000000000);
  return pyobj;
}


SWIGINTERN int IOIQty_LARGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQty_LARGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIQty_LARGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IOIQty_LARGE);
  return pyobj;
}


SWIGINTERN int IOIQty_SMALL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQty_SMALL is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIQty_SMALL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IOIQty_SMALL);
  return pyobj;
}


SWIGINTERN int IOIQty_UNDISCLOSED_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQty_UNDISCLOSED_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIQty_UNDISCLOSED_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IOIQty_UNDISCLOSED_QUANTITY);
  return pyobj;
}


SWIGINTERN int 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 *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 ApplResponseError_APPLICATION_DOES_NOT_EXIST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplResponseError_APPLICATION_DOES_NOT_EXIST is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 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 *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 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 *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 LastLiquidityInd_ADDEDLIQUIDITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastLiquidityInd_ADDEDLIQUIDITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *LastLiquidityInd_ADDEDLIQUIDITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LastLiquidityInd_ADDEDLIQUIDITY));
  return pyobj;
}


SWIGINTERN int LastLiquidityInd_LIQUIDITY_ROUTED_OUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastLiquidityInd_LIQUIDITY_ROUTED_OUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 LastLiquidityInd_LIQUIDITYROUTEDOUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastLiquidityInd_LIQUIDITYROUTEDOUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *LastLiquidityInd_LIQUIDITYROUTEDOUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LastLiquidityInd_LIQUIDITYROUTEDOUT));
  return pyobj;
}


SWIGINTERN int LastLiquidityInd_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastLiquidityInd_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *LastLiquidityInd_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LastLiquidityInd_AUCTION));
  return pyobj;
}


SWIGINTERN int LastLiquidityInd_REMOVEDLIQUIDITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastLiquidityInd_REMOVEDLIQUIDITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *LastLiquidityInd_REMOVEDLIQUIDITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LastLiquidityInd_REMOVEDLIQUIDITY));
  return pyobj;
}


SWIGINTERN int LastLiquidityInd_ADDED_LIQUIDITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastLiquidityInd_ADDED_LIQUIDITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *LastLiquidityInd_ADDED_LIQUIDITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LastLiquidityInd_ADDED_LIQUIDITY));
  return pyobj;
}


SWIGINTERN int LastLiquidityInd_REMOVED_LIQUIDITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastLiquidityInd_REMOVED_LIQUIDITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *LastLiquidityInd_REMOVED_LIQUIDITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LastLiquidityInd_REMOVED_LIQUIDITY));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 StrikePriceDeterminationMethod_FIXED_STRIKE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrikePriceDeterminationMethod_FIXED_STRIKE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StrikePriceDeterminationMethod_FIXED_STRIKE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrikePriceDeterminationMethod_FIXED_STRIKE));
  return pyobj;
}


SWIGINTERN int 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 *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 TargetStrategy_MININIZEMARKETIMPACT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TargetStrategy_MININIZEMARKETIMPACT is read-only.");
  return 1;
}


SWIGINTERN PyObject *TargetStrategy_MININIZEMARKETIMPACT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TargetStrategy_MININIZEMARKETIMPACT));
  return pyobj;
}


SWIGINTERN int TargetStrategy_RESERVEDANDAVAILABLEFORBILATERALLYAGREEDUPONUSERDEFINEDVALUES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TargetStrategy_RESERVEDANDAVAILABLEFORBILATERALLYAGREEDUPONUSERDEFINEDVALUES is read-only.");
  return 1;
}


SWIGINTERN PyObject *TargetStrategy_RESERVEDANDAVAILABLEFORBILATERALLYAGREEDUPONUSERDEFINEDVALUES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TargetStrategy_RESERVEDANDAVAILABLEFORBILATERALLYAGREEDUPONUSERDEFINEDVALUES));
  return pyobj;
}


SWIGINTERN int TargetStrategy_PARTICIPATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TargetStrategy_PARTICIPATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TargetStrategy_PARTICIPATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TargetStrategy_PARTICIPATE));
  return pyobj;
}


SWIGINTERN int TargetStrategy_MININIZE_MARKET_IMPACT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TargetStrategy_MININIZE_MARKET_IMPACT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TargetStrategy_VWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TargetStrategy_VWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *TargetStrategy_VWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TargetStrategy_VWAP));
  return pyobj;
}


SWIGINTERN int DueToRelated_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DueToRelated_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *DueToRelated_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DueToRelated_NO));
  return pyobj;
}


SWIGINTERN int DueToRelated_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DueToRelated_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *DueToRelated_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DueToRelated_YES));
  return pyobj;
}


SWIGINTERN int UnderlyingCashType_DIFF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingCashType_DIFF is read-only.");
  return 1;
}


SWIGINTERN PyObject *UnderlyingCashType_DIFF_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnderlyingCashType_DIFF);
  return pyobj;
}


SWIGINTERN int UnderlyingCashType_FIXED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingCashType_FIXED is read-only.");
  return 1;
}


SWIGINTERN PyObject *UnderlyingCashType_FIXED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnderlyingCashType_FIXED);
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 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 *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 CustOrderCapacity_ALL_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderCapacity_ALL_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *CustOrderCapacity_ALL_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CustOrderCapacity_ALL_OTHER));
  return pyobj;
}


SWIGINTERN int OwnershipType_JOINT_TRUSTEES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnershipType_JOINT_TRUSTEES is read-only.");
  return 1;
}


SWIGINTERN PyObject *OwnershipType_JOINT_TRUSTEES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OwnershipType_JOINT_TRUSTEES));
  return pyobj;
}


SWIGINTERN int OwnershipType_JOINT_INVESTORS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnershipType_JOINT_INVESTORS is read-only.");
  return 1;
}


SWIGINTERN PyObject *OwnershipType_JOINT_INVESTORS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OwnershipType_JOINT_INVESTORS));
  return pyobj;
}


SWIGINTERN int OwnershipType_TENANTS_IN_COMMON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnershipType_TENANTS_IN_COMMON is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 UnitOfMeasure_US_DOLLARS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_US_DOLLARS is read-only.");
  return 1;
}


SWIGINTERN PyObject *UnitOfMeasure_US_DOLLARS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_US_DOLLARS);
  return pyobj;
}


SWIGINTERN int UnitOfMeasure_TROY_OUNCES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_TROY_OUNCES is read-only.");
  return 1;
}


SWIGINTERN PyObject *UnitOfMeasure_TROY_OUNCES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_TROY_OUNCES);
  return pyobj;
}


SWIGINTERN int UnitOfMeasure_TONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_TONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *UnitOfMeasure_TONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_TONS);
  return pyobj;
}


SWIGINTERN int UnitOfMeasure_BILLION_CUBIC_FEET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_BILLION_CUBIC_FEET is read-only.");
  return 1;
}


SWIGINTERN PyObject *UnitOfMeasure_BILLION_CUBIC_FEET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_BILLION_CUBIC_FEET);
  return pyobj;
}


SWIGINTERN int UnitOfMeasure_ONE_MILLION_BTU_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_ONE_MILLION_BTU is read-only.");
  return 1;
}


SWIGINTERN PyObject *UnitOfMeasure_ONE_MILLION_BTU_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_ONE_MILLION_BTU);
  return pyobj;
}


SWIGINTERN int UnitOfMeasure_MEGAWATT_HOURS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_MEGAWATT_HOURS is read-only.");
  return 1;
}


SWIGINTERN PyObject *UnitOfMeasure_MEGAWATT_HOURS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_MEGAWATT_HOURS);
  return pyobj;
}


SWIGINTERN int UnitOfMeasure_MILLION_BARRELS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_MILLION_BARRELS is read-only.");
  return 1;
}


SWIGINTERN PyObject *UnitOfMeasure_MILLION_BARRELS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_MILLION_BARRELS);
  return pyobj;
}


SWIGINTERN int UnitOfMeasure_GALLONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_GALLONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *UnitOfMeasure_GALLONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_GALLONS);
  return pyobj;
}


SWIGINTERN int UnitOfMeasure_BARRELS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_BARRELS is read-only.");
  return 1;
}


SWIGINTERN PyObject *UnitOfMeasure_BARRELS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_BARRELS);
  return pyobj;
}


SWIGINTERN int UnitOfMeasure_POUNDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_POUNDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *UnitOfMeasure_POUNDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_POUNDS);
  return pyobj;
}


SWIGINTERN int UnitOfMeasure_METRIC_TONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_METRIC_TONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *UnitOfMeasure_METRIC_TONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_METRIC_TONS);
  return pyobj;
}


SWIGINTERN int UnitOfMeasure_ALLOWANCES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_ALLOWANCES is read-only.");
  return 1;
}


SWIGINTERN PyObject *UnitOfMeasure_ALLOWANCES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_ALLOWANCES);
  return pyobj;
}


SWIGINTERN int UnitOfMeasure_BUSHELS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_BUSHELS is read-only.");
  return 1;
}


SWIGINTERN PyObject *UnitOfMeasure_BUSHELS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_BUSHELS);
  return pyobj;
}


SWIGINTERN int SecDefStatus_INVALID_DEFINITION_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecDefStatus_INVALID_DEFINITION_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecDefStatus_INVALID_DEFINITION_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecDefStatus_INVALID_DEFINITION_REQUEST));
  return pyobj;
}


SWIGINTERN int SecDefStatus_PENDING_APPROVAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecDefStatus_PENDING_APPROVAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecDefStatus_PENDING_APPROVAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecDefStatus_PENDING_APPROVAL));
  return pyobj;
}


SWIGINTERN int SecDefStatus_APPROVED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecDefStatus_APPROVED is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecDefStatus_APPROVED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecDefStatus_APPROVED));
  return pyobj;
}


SWIGINTERN int SecDefStatus_UNAUTHORIZEDREQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecDefStatus_UNAUTHORIZEDREQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecDefStatus_UNAUTHORIZEDREQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecDefStatus_UNAUTHORIZEDREQUEST));
  return pyobj;
}


SWIGINTERN int SecDefStatus_PENDINGAPPROVAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecDefStatus_PENDINGAPPROVAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecDefStatus_PENDINGAPPROVAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecDefStatus_PENDINGAPPROVAL));
  return pyobj;
}


SWIGINTERN int SecDefStatus_UNAUTHORIZED_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecDefStatus_UNAUTHORIZED_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecDefStatus_UNAUTHORIZED_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecDefStatus_UNAUTHORIZED_REQUEST));
  return pyobj;
}


SWIGINTERN int SecDefStatus_INVALIDDEFINITIONREQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecDefStatus_INVALIDDEFINITIONREQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecDefStatus_INVALIDDEFINITIONREQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecDefStatus_INVALIDDEFINITIONREQUEST));
  return pyobj;
}


SWIGINTERN int SecDefStatus_APPROVEDACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecDefStatus_APPROVEDACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecDefStatus_APPROVEDACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecDefStatus_APPROVEDACCEPTED));
  return pyobj;
}


SWIGINTERN int SecDefStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecDefStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecDefStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecDefStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int SettlmntTyp_WHEN_AND_IF_ISSUED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_WHEN_AND_IF_ISSUED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SettlmntTyp_T_PLUS_1_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_T_PLUS_1 is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SettlmntTyp_FUTURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_FUTURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlmntTyp_FUTURE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_FUTURE));
  return pyobj;
}


SWIGINTERN int SettlmntTyp_SELLERS_OPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_SELLERS_OPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlmntTyp_SELLERS_OPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_SELLERS_OPTION));
  return pyobj;
}


SWIGINTERN int SettlmntTyp_T_PLUS_2_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_T_PLUS_2 is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SettlmntTyp_T_PLUS_3_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_T_PLUS_3 is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SettlmntTyp_T_PLUS_4_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_T_PLUS_4 is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SettlmntTyp_REGULAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_REGULAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlmntTyp_REGULAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_REGULAR));
  return pyobj;
}


SWIGINTERN int SettlmntTyp_T_PLUS_5_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_T_PLUS_5 is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SettlmntTyp_WHEN_ISSUED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_WHEN_ISSUED is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlmntTyp_WHEN_ISSUED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_WHEN_ISSUED));
  return pyobj;
}


SWIGINTERN int SettlmntTyp_NEXT_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_NEXT_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlmntTyp_NEXT_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_NEXT_DAY));
  return pyobj;
}


SWIGINTERN int SettlmntTyp_CASH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_CASH is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlmntTyp_CASH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_CASH));
  return pyobj;
}


SWIGINTERN int TradePublishIndicator_DO_NOT_PUBLISH_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePublishIndicator_DO_NOT_PUBLISH_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TradePublishIndicator_DEFERRED_PUBLICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePublishIndicator_DEFERRED_PUBLICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradePublishIndicator_DEFERRED_PUBLICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePublishIndicator_DEFERRED_PUBLICATION));
  return pyobj;
}


SWIGINTERN int TradePublishIndicator_PUBLISH_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePublishIndicator_PUBLISH_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradePublishIndicator_PUBLISH_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePublishIndicator_PUBLISH_TRADE));
  return pyobj;
}


SWIGINTERN int ApplResponseType_MESSAGES_NOT_AVAILABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplResponseType_MESSAGES_NOT_AVAILABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ApplResponseType_APPLICATION_DOES_NOT_EXIST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplResponseType_APPLICATION_DOES_NOT_EXIST is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ApplResponseType_REQUEST_SUCCESSFULLY_PROCESSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplResponseType_REQUEST_SUCCESSFULLY_PROCESSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 StandInstDbType_SID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StandInstDbType_SID is read-only.");
  return 1;
}


SWIGINTERN PyObject *StandInstDbType_SID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StandInstDbType_SID));
  return pyobj;
}


SWIGINTERN int StandInstDbType_DTC_SID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StandInstDbType_DTC_SID is read-only.");
  return 1;
}


SWIGINTERN PyObject *StandInstDbType_DTC_SID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StandInstDbType_DTC_SID));
  return pyobj;
}


SWIGINTERN int StandInstDbType_CUSTODIAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StandInstDbType_CUSTODIAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *StandInstDbType_CUSTODIAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StandInstDbType_CUSTODIAN));
  return pyobj;
}


SWIGINTERN int StandInstDbType_ALERT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StandInstDbType_ALERT is read-only.");
  return 1;
}


SWIGINTERN PyObject *StandInstDbType_ALERT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StandInstDbType_ALERT));
  return pyobj;
}


SWIGINTERN int StandInstDbType_ACCOUNTNET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StandInstDbType_ACCOUNTNET is read-only.");
  return 1;
}


SWIGINTERN PyObject *StandInstDbType_ACCOUNTNET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StandInstDbType_ACCOUNTNET));
  return pyobj;
}


SWIGINTERN int StandInstDbType_A_GLOBAL_CUSTODIAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StandInstDbType_A_GLOBAL_CUSTODIAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 StandInstDbType_THOMSON_ALERT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StandInstDbType_THOMSON_ALERT is read-only.");
  return 1;
}


SWIGINTERN PyObject *StandInstDbType_THOMSON_ALERT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StandInstDbType_THOMSON_ALERT));
  return pyobj;
}


SWIGINTERN int StandInstDbType_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StandInstDbType_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *StandInstDbType_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StandInstDbType_OTHER));
  return pyobj;
}


SWIGINTERN int QuoteEntryStatus_CROSS_MARKET_WARNING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryStatus_CROSS_MARKET_WARNING is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 QuoteEntryStatus_LOCKED_MARKET_WARNING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryStatus_LOCKED_MARKET_WARNING is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 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 *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 QuoteEntryStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteEntryStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int QuoteEntryStatus_EXPIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryStatus_EXPIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteEntryStatus_EXPIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_EXPIRED));
  return pyobj;
}


SWIGINTERN int QuoteEntryStatus_REMOVED_FROM_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryStatus_REMOVED_FROM_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 QuoteEntryStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteEntryStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int QuoteEntryStatus_ACTIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryStatus_ACTIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteEntryStatus_ACTIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_ACTIVE));
  return pyobj;
}


SWIGINTERN int TriggerPriceType_BEST_MID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerPriceType_BEST_MID is read-only.");
  return 1;
}


SWIGINTERN PyObject *TriggerPriceType_BEST_MID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerPriceType_BEST_MID));
  return pyobj;
}


SWIGINTERN int 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 *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 TriggerPriceType_BEST_BID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerPriceType_BEST_BID is read-only.");
  return 1;
}


SWIGINTERN PyObject *TriggerPriceType_BEST_BID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerPriceType_BEST_BID));
  return pyobj;
}


SWIGINTERN int 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 *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 TriggerPriceType_BEST_OFFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerPriceType_BEST_OFFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *TriggerPriceType_BEST_OFFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerPriceType_BEST_OFFER));
  return pyobj;
}


SWIGINTERN int TriggerPriceType_LAST_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerPriceType_LAST_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TriggerPriceType_LAST_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerPriceType_LAST_TRADE));
  return pyobj;
}


SWIGINTERN int SideTrdSubTyp_EXTERNAL_TRANSFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideTrdSubTyp_EXTERNAL_TRANSFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *SideTrdSubTyp_EXTERNAL_TRANSFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideTrdSubTyp_EXTERNAL_TRANSFER));
  return pyobj;
}


SWIGINTERN int SideTrdSubTyp_TRANSACTION_FROM_ASSIGNMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideTrdSubTyp_TRANSACTION_FROM_ASSIGNMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SideTrdSubTyp_TRANSACTION_FROM_ASSIGNMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideTrdSubTyp_TRANSACTION_FROM_ASSIGNMENT));
  return pyobj;
}


SWIGINTERN int SideTrdSubTyp_TRANSACTION_FROM_EXERCISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideTrdSubTyp_TRANSACTION_FROM_EXERCISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SideTrdSubTyp_TRANSACTION_FROM_EXERCISE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideTrdSubTyp_TRANSACTION_FROM_EXERCISE));
  return pyobj;
}


SWIGINTERN int SideTrdSubTyp_DIFFERENTIAL_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideTrdSubTyp_DIFFERENTIAL_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *SideTrdSubTyp_DIFFERENTIAL_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideTrdSubTyp_DIFFERENTIAL_SPREAD));
  return pyobj;
}


SWIGINTERN int SideTrdSubTyp_ONSET_DUE_TO_AN_ALLOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideTrdSubTyp_ONSET_DUE_TO_AN_ALLOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *SideTrdSubTyp_ONSET_DUE_TO_AN_ALLOCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideTrdSubTyp_ONSET_DUE_TO_AN_ALLOCATION));
  return pyobj;
}


SWIGINTERN int SideTrdSubTyp_REJECT_FOR_SUBMITTING_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideTrdSubTyp_REJECT_FOR_SUBMITTING_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SideTrdSubTyp_REJECT_FOR_SUBMITTING_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideTrdSubTyp_REJECT_FOR_SUBMITTING_TRADE));
  return pyobj;
}


SWIGINTERN int SideTrdSubTyp_CMTA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideTrdSubTyp_CMTA is read-only.");
  return 1;
}


SWIGINTERN PyObject *SideTrdSubTyp_CMTA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideTrdSubTyp_CMTA));
  return pyobj;
}


SWIGINTERN int SideTrdSubTyp_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideTrdSubTyp_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SideTrdSubTyp_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideTrdSubTyp_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT));
  return pyobj;
}


SWIGINTERN int SideTrdSubTyp_INTERNAL_TRANSFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideTrdSubTyp_INTERNAL_TRANSFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *SideTrdSubTyp_INTERNAL_TRANSFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideTrdSubTyp_INTERNAL_TRANSFER));
  return pyobj;
}


SWIGINTERN int SideTrdSubTyp_OFFSET_DUE_TO_AN_ALLOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideTrdSubTyp_OFFSET_DUE_TO_AN_ALLOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *SideTrdSubTyp_OFFSET_DUE_TO_AN_ALLOCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideTrdSubTyp_OFFSET_DUE_TO_AN_ALLOCATION));
  return pyobj;
}


SWIGINTERN int SideTrdSubTyp_ADVISORY_FOR_CONTRA_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideTrdSubTyp_ADVISORY_FOR_CONTRA_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SideTrdSubTyp_ADVISORY_FOR_CONTRA_SIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideTrdSubTyp_ADVISORY_FOR_CONTRA_SIDE));
  return pyobj;
}


SWIGINTERN int SettlInstReqRejCode_UNABLE_TO_PROCESS_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstReqRejCode_UNABLE_TO_PROCESS_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SettlInstReqRejCode_NOMATCHINGSETTLEMENTINSTRUCTIONSFOUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstReqRejCode_NOMATCHINGSETTLEMENTINSTRUCTIONSFOUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlInstReqRejCode_NOMATCHINGSETTLEMENTINSTRUCTIONSFOUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlInstReqRejCode_NOMATCHINGSETTLEMENTINSTRUCTIONSFOUND));
  return pyobj;
}


SWIGINTERN int SettlInstReqRejCode_UNKNOWNACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstReqRejCode_UNKNOWNACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlInstReqRejCode_UNKNOWNACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlInstReqRejCode_UNKNOWNACCOUNT));
  return pyobj;
}


SWIGINTERN int SettlInstReqRejCode_UNABLETOPROCESSREQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstReqRejCode_UNABLETOPROCESSREQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlInstReqRejCode_UNABLETOPROCESSREQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlInstReqRejCode_UNABLETOPROCESSREQUEST));
  return pyobj;
}


SWIGINTERN int SettlInstReqRejCode_UNKNOWN_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstReqRejCode_UNKNOWN_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlInstReqRejCode_UNKNOWN_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlInstReqRejCode_UNKNOWN_ACCOUNT));
  return pyobj;
}


SWIGINTERN int 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 *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 SettlInstReqRejCode_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstReqRejCode_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlInstReqRejCode_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlInstReqRejCode_OTHER));
  return pyobj;
}


SWIGINTERN int Urgency_FLASH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Urgency_FLASH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Urgency_FLASH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Urgency_FLASH));
  return pyobj;
}


SWIGINTERN int Urgency_NORMAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Urgency_NORMAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Urgency_NORMAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Urgency_NORMAL));
  return pyobj;
}


SWIGINTERN int Urgency_BACKGROUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Urgency_BACKGROUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Urgency_BACKGROUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Urgency_BACKGROUND));
  return pyobj;
}


SWIGINTERN int CollAsgnTransType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnTransType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollAsgnTransType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnTransType_REPLACE));
  return pyobj;
}


SWIGINTERN int CollAsgnTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollAsgnTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnTransType_NEW));
  return pyobj;
}


SWIGINTERN int CollAsgnTransType_REVERSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnTransType_REVERSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollAsgnTransType_REVERSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnTransType_REVERSE));
  return pyobj;
}


SWIGINTERN int CollAsgnTransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnTransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollAsgnTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnTransType_CANCEL));
  return pyobj;
}


SWIGINTERN int CollAsgnTransType_RELEASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnTransType_RELEASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollAsgnTransType_RELEASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnTransType_RELEASE));
  return pyobj;
}


SWIGINTERN int PaymentMethod_FED_WIRE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_FED_WIRE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PaymentMethod_FED_WIRE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_FED_WIRE));
  return pyobj;
}


SWIGINTERN int PaymentMethod_ACHCREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_ACHCREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *PaymentMethod_ACHCREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_ACHCREDIT));
  return pyobj;
}


SWIGINTERN int PaymentMethod_TELEGRAPHICTRANSFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_TELEGRAPHICTRANSFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *PaymentMethod_TELEGRAPHICTRANSFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_TELEGRAPHICTRANSFER));
  return pyobj;
}


SWIGINTERN int PaymentMethod_DIRECTDEBITBECS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_DIRECTDEBITBECS is read-only.");
  return 1;
}


SWIGINTERN PyObject *PaymentMethod_DIRECTDEBITBECS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_DIRECTDEBITBECS));
  return pyobj;
}


SWIGINTERN int PaymentMethod_EUROCLEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_EUROCLEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *PaymentMethod_EUROCLEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_EUROCLEAR));
  return pyobj;
}


SWIGINTERN int PaymentMethod_ACH_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_ACH_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *PaymentMethod_ACH_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_ACH_CREDIT));
  return pyobj;
}


SWIGINTERN int PaymentMethod_TELEGRAPHIC_TRANSFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_TELEGRAPHIC_TRANSFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *PaymentMethod_TELEGRAPHIC_TRANSFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_TELEGRAPHIC_TRANSFER));
  return pyobj;
}


SWIGINTERN int PaymentMethod_FEDWIRE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_FEDWIRE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PaymentMethod_FEDWIRE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_FEDWIRE));
  return pyobj;
}


SWIGINTERN int PaymentMethod_CREDITCARD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_CREDITCARD is read-only.");
  return 1;
}


SWIGINTERN PyObject *PaymentMethod_CREDITCARD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_CREDITCARD));
  return pyobj;
}


SWIGINTERN int PaymentMethod_DIRECT_DEBIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_DIRECT_DEBIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *PaymentMethod_DIRECT_DEBIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_DIRECT_DEBIT));
  return pyobj;
}


SWIGINTERN int PaymentMethod_CREDIT_CARD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_CREDIT_CARD is read-only.");
  return 1;
}


SWIGINTERN PyObject *PaymentMethod_CREDIT_CARD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_CREDIT_CARD));
  return pyobj;
}


SWIGINTERN int PaymentMethod_CHEQUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_CHEQUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PaymentMethod_CHEQUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_CHEQUE));
  return pyobj;
}


SWIGINTERN int PaymentMethod_DIRECT_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_DIRECT_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *PaymentMethod_DIRECT_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_DIRECT_CREDIT));
  return pyobj;
}


SWIGINTERN int PaymentMethod_CREST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_CREST is read-only.");
  return 1;
}


SWIGINTERN PyObject *PaymentMethod_CREST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_CREST));
  return pyobj;
}


SWIGINTERN int PaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_HIGH_VALUE_CLEARING_SYSTEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PaymentMethod_DEBITCARD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_DEBITCARD is read-only.");
  return 1;
}


SWIGINTERN PyObject *PaymentMethod_DEBITCARD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_DEBITCARD));
  return pyobj;
}


SWIGINTERN int PaymentMethod_CLEARSTREAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_CLEARSTREAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *PaymentMethod_CLEARSTREAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_CLEARSTREAM));
  return pyobj;
}


SWIGINTERN int PaymentMethod_BPAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_BPAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PaymentMethod_BPAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_BPAY));
  return pyobj;
}


SWIGINTERN int PaymentMethod_HIGHVALUECLEARINGSYSTEMHVACS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_HIGHVALUECLEARINGSYSTEMHVACS is read-only.");
  return 1;
}


SWIGINTERN PyObject *PaymentMethod_HIGHVALUECLEARINGSYSTEMHVACS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_HIGHVALUECLEARINGSYSTEMHVACS));
  return pyobj;
}


SWIGINTERN int PaymentMethod_NSCC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_NSCC is read-only.");
  return 1;
}


SWIGINTERN PyObject *PaymentMethod_NSCC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_NSCC));
  return pyobj;
}


SWIGINTERN int PaymentMethod_DEBIT_CARD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_DEBIT_CARD is read-only.");
  return 1;
}


SWIGINTERN PyObject *PaymentMethod_DEBIT_CARD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_DEBIT_CARD));
  return pyobj;
}


SWIGINTERN int PaymentMethod_ACHDEBIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_ACHDEBIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *PaymentMethod_ACHDEBIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_ACHDEBIT));
  return pyobj;
}


SWIGINTERN int PaymentMethod_DIRECTCREDITBECS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_DIRECTCREDITBECS is read-only.");
  return 1;
}


SWIGINTERN PyObject *PaymentMethod_DIRECTCREDITBECS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_DIRECTCREDITBECS));
  return pyobj;
}


SWIGINTERN int PaymentMethod_ACH_DEBIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_ACH_DEBIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *PaymentMethod_ACH_DEBIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_ACH_DEBIT));
  return pyobj;
}


SWIGINTERN int TriggerPriceTypeScope_LOCAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerPriceTypeScope_LOCAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *TriggerPriceTypeScope_LOCAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerPriceTypeScope_LOCAL));
  return pyobj;
}


SWIGINTERN int TriggerPriceTypeScope_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerPriceTypeScope_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TriggerPriceTypeScope_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerPriceTypeScope_NONE));
  return pyobj;
}


SWIGINTERN int TriggerPriceTypeScope_GLOBAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerPriceTypeScope_GLOBAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *TriggerPriceTypeScope_GLOBAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerPriceTypeScope_GLOBAL));
  return pyobj;
}


SWIGINTERN int TriggerPriceTypeScope_NATIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerPriceTypeScope_NATIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *TriggerPriceTypeScope_NATIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerPriceTypeScope_NATIONAL));
  return pyobj;
}


SWIGINTERN int PegLimitType_STRICT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegLimitType_STRICT is read-only.");
  return 1;
}


SWIGINTERN PyObject *PegLimitType_STRICT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegLimitType_STRICT));
  return pyobj;
}


SWIGINTERN int PegLimitType_ORWORSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegLimitType_ORWORSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PegLimitType_ORWORSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegLimitType_ORWORSE));
  return pyobj;
}


SWIGINTERN int PegLimitType_OR_BETTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegLimitType_OR_BETTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *PegLimitType_OR_BETTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegLimitType_OR_BETTER));
  return pyobj;
}


SWIGINTERN int PegLimitType_OR_WORSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegLimitType_OR_WORSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PegLimitType_OR_WORSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegLimitType_OR_WORSE));
  return pyobj;
}


SWIGINTERN int PegLimitType_ORBETTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegLimitType_ORBETTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *PegLimitType_ORBETTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegLimitType_ORBETTER));
  return pyobj;
}


SWIGINTERN int Side_BORROW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_BORROW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Side_BORROW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_BORROW));
  return pyobj;
}


SWIGINTERN int Side_SELLPLUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_SELLPLUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Side_SELLPLUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_SELLPLUS));
  return pyobj;
}


SWIGINTERN int Side_BUY_MINUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_BUY_MINUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Side_BUY_MINUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_BUY_MINUS));
  return pyobj;
}


SWIGINTERN int Side_BUYMIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_BUYMIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Side_BUYMIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_BUYMIN));
  return pyobj;
}


SWIGINTERN int Side_ASDEFINED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_ASDEFINED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Side_ASDEFINED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_ASDEFINED));
  return pyobj;
}


SWIGINTERN int Side_SUBSCRIBE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_SUBSCRIBE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Side_SUBSCRIBE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_SUBSCRIBE));
  return pyobj;
}


SWIGINTERN int Side_CROSS_SHORT_EXEMPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_CROSS_SHORT_EXEMPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 Side_UNDISCLOSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_UNDISCLOSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Side_UNDISCLOSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_UNDISCLOSED));
  return pyobj;
}


SWIGINTERN int Side_SELLSHT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_SELLSHT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Side_SELLSHT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_SELLSHT));
  return pyobj;
}


SWIGINTERN int Side_SELLSHTEX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_SELLSHTEX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Side_SELLSHTEX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_SELLSHTEX));
  return pyobj;
}


SWIGINTERN int Side_CROSSSHORTEX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_CROSSSHORTEX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Side_CROSSSHORTEX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_CROSSSHORTEX));
  return pyobj;
}


SWIGINTERN int Side_CROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_CROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Side_CROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_CROSS));
  return pyobj;
}


SWIGINTERN int Side_SELL_SHORT_EXEMPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_SELL_SHORT_EXEMPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 Side_UNDISC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_UNDISC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Side_UNDISC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_UNDISC));
  return pyobj;
}


SWIGINTERN int Side_CROSSSHORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_CROSSSHORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Side_CROSSSHORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_CROSSSHORT));
  return pyobj;
}


SWIGINTERN int Side_BORROWFINANCING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_BORROWFINANCING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Side_BORROWFINANCING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_BORROWFINANCING));
  return pyobj;
}


SWIGINTERN int Side_BUY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_BUY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Side_BUY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_BUY));
  return pyobj;
}


SWIGINTERN int Side_CROSS_SHORT_EXXMPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_CROSS_SHORT_EXXMPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 Side_SELL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_SELL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Side_SELL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_SELL));
  return pyobj;
}


SWIGINTERN int Side_LEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_LEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Side_LEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_LEND));
  return pyobj;
}


SWIGINTERN int Side_SELL_SHORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_SELL_SHORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Side_SELL_SHORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_SELL_SHORT));
  return pyobj;
}


SWIGINTERN int Side_OPPOSITE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_OPPOSITE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Side_OPPOSITE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_OPPOSITE));
  return pyobj;
}


SWIGINTERN int Side_CROSS_SHORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_CROSS_SHORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Side_CROSS_SHORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_CROSS_SHORT));
  return pyobj;
}


SWIGINTERN int Side_SELL_PLUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_SELL_PLUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Side_SELL_PLUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_SELL_PLUS));
  return pyobj;
}


SWIGINTERN int Side_REDEEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_REDEEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Side_REDEEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_REDEEM));
  return pyobj;
}


SWIGINTERN int Side_LENDFINANCING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_LENDFINANCING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Side_LENDFINANCING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_LENDFINANCING));
  return pyobj;
}


SWIGINTERN int Side_AS_DEFINED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_AS_DEFINED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Side_AS_DEFINED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_AS_DEFINED));
  return pyobj;
}


SWIGINTERN int ContAmtType_COMMISSIONAMT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_COMMISSIONAMT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ContAmtType_COMMISSIONAMT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_COMMISSIONAMT));
  return pyobj;
}


SWIGINTERN int ContAmtType_FUNDBASEDRENEWALCOMM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_FUNDBASEDRENEWALCOMM is read-only.");
  return 1;
}


SWIGINTERN PyObject *ContAmtType_FUNDBASEDRENEWALCOMM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_FUNDBASEDRENEWALCOMM));
  return pyobj;
}


SWIGINTERN int ContAmtType_INITIALCHARGEPCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_INITIALCHARGEPCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ContAmtType_INITIALCHARGEPCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_INITIALCHARGEPCT));
  return pyobj;
}


SWIGINTERN int ContAmtType_EXITCHARGEAMT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_EXITCHARGEAMT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ContAmtType_EXITCHARGEAMT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_EXITCHARGEAMT));
  return pyobj;
}


SWIGINTERN int ContAmtType_EXIT_CHARGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_EXIT_CHARGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ContAmtType_EXIT_CHARGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_EXIT_CHARGE));
  return pyobj;
}


SWIGINTERN int ContAmtType_DILUTION_LEVY_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_DILUTION_LEVY_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ContAmtType_DILUTION_LEVY_PERCENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_DILUTION_LEVY_PERCENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ContAmtType_DISCOUNT_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_DISCOUNT_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ContAmtType_DISCOUNT_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_DISCOUNT_AMOUNT));
  return pyobj;
}


SWIGINTERN int ContAmtType_COMMISSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_COMMISSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *ContAmtType_COMMISSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_COMMISSION));
  return pyobj;
}


SWIGINTERN int ContAmtType_INITIAL_CHARGE_PERCENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_INITIAL_CHARGE_PERCENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ContAmtType_DILUTIONLEVYAMT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_DILUTIONLEVYAMT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ContAmtType_DILUTIONLEVYAMT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_DILUTIONLEVYAMT));
  return pyobj;
}


SWIGINTERN int ContAmtType_DILUTION_LEVY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_DILUTION_LEVY is read-only.");
  return 1;
}


SWIGINTERN PyObject *ContAmtType_DILUTION_LEVY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_DILUTION_LEVY));
  return pyobj;
}


SWIGINTERN int ContAmtType_COMMISSION_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_COMMISSION_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ContAmtType_COMMISSION_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_COMMISSION_AMOUNT));
  return pyobj;
}


SWIGINTERN int ContAmtType_NET_SETTLEMENT_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_NET_SETTLEMENT_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ContAmtType_EXITCHARGEPCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_EXITCHARGEPCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ContAmtType_EXITCHARGEPCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_EXITCHARGEPCT));
  return pyobj;
}


SWIGINTERN int ContAmtType_COMMISSIONPCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_COMMISSIONPCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ContAmtType_COMMISSIONPCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_COMMISSIONPCT));
  return pyobj;
}


SWIGINTERN int ContAmtType_FUND_BASED_RENEWAL_COMMISSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_FUND_BASED_RENEWAL_COMMISSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ContAmtType_DISCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_DISCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ContAmtType_DISCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_DISCOUNT));
  return pyobj;
}


SWIGINTERN int ContAmtType_FUNDBASEDRENEWALCOMMAMTORD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_FUNDBASEDRENEWALCOMMAMTORD is read-only.");
  return 1;
}


SWIGINTERN PyObject *ContAmtType_FUNDBASEDRENEWALCOMMAMTORD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_FUNDBASEDRENEWALCOMMAMTORD));
  return pyobj;
}


SWIGINTERN int ContAmtType_DISCOUNTPCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_DISCOUNTPCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ContAmtType_DISCOUNTPCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_DISCOUNTPCT));
  return pyobj;
}


SWIGINTERN int 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 *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 ContAmtType_EXIT_CHARGE_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_EXIT_CHARGE_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ContAmtType_INITIAL_CHARGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_INITIAL_CHARGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ContAmtType_INITIAL_CHARGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_INITIAL_CHARGE));
  return pyobj;
}


SWIGINTERN int ContAmtType_EXIT_CHARGE_PERCENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_EXIT_CHARGE_PERCENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ContAmtType_DISCOUNT_PERCENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_DISCOUNT_PERCENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ContAmtType_DISCOUNT_PERCENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_DISCOUNT_PERCENT));
  return pyobj;
}


SWIGINTERN int ContAmtType_INITIALCHARGEAMT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_INITIALCHARGEAMT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ContAmtType_INITIALCHARGEAMT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_INITIALCHARGEAMT));
  return pyobj;
}


SWIGINTERN int ContAmtType_DILUTIONLEVYPCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_DILUTIONLEVYPCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ContAmtType_DILUTIONLEVYPCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_DILUTIONLEVYPCT));
  return pyobj;
}


SWIGINTERN int 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 *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 ContAmtType_FUNDBASEDRENEWALCOMMAMTPROJ_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_FUNDBASEDRENEWALCOMMAMTPROJ is read-only.");
  return 1;
}


SWIGINTERN PyObject *ContAmtType_FUNDBASEDRENEWALCOMMAMTPROJ_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_FUNDBASEDRENEWALCOMMAMTPROJ));
  return pyobj;
}


SWIGINTERN int ContAmtType_NETSETTLEMENTAMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_NETSETTLEMENTAMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ContAmtType_NETSETTLEMENTAMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_NETSETTLEMENTAMOUNT));
  return pyobj;
}


SWIGINTERN int ContAmtType_PROJECTEDFUNDVALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_PROJECTEDFUNDVALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ContAmtType_PROJECTEDFUNDVALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_PROJECTEDFUNDVALUE));
  return pyobj;
}


SWIGINTERN int ContAmtType_DISCOUNTAMT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_DISCOUNTAMT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ContAmtType_DISCOUNTAMT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_DISCOUNTAMT));
  return pyobj;
}


SWIGINTERN int 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 *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 ContAmtType_COMMISSION_PERCENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_COMMISSION_PERCENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ContAmtType_COMMISSION_PERCENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_COMMISSION_PERCENT));
  return pyobj;
}


SWIGINTERN int ContAmtType_PROJECTED_FUND_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_PROJECTED_FUND_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ContAmtType_INITIAL_CHARGE_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_INITIAL_CHARGE_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 OrderCategory_IMPLIED_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCategory_IMPLIED_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderCategory_IMPLIED_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCategory_IMPLIED_ORDER));
  return pyobj;
}


SWIGINTERN int OrderCategory_STREAMING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCategory_STREAMING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderCategory_STREAMING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCategory_STREAMING_PRICE));
  return pyobj;
}


SWIGINTERN int OrderCategory_QUOTE_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCategory_QUOTE_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderCategory_QUOTE_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCategory_QUOTE_REQUEST));
  return pyobj;
}


SWIGINTERN int OrderCategory_CROSS_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCategory_CROSS_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderCategory_CROSS_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCategory_CROSS_ORDER));
  return pyobj;
}


SWIGINTERN int OrderCategory_MULTILEG_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCategory_MULTILEG_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderCategory_MULTILEG_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCategory_MULTILEG_ORDER));
  return pyobj;
}


SWIGINTERN int OrderCategory_PRIVATELY_NEGOTIATED_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCategory_PRIVATELY_NEGOTIATED_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 OrderCategory_QUOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCategory_QUOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderCategory_QUOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCategory_QUOTE));
  return pyobj;
}


SWIGINTERN int OrderCategory_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCategory_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderCategory_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCategory_ORDER));
  return pyobj;
}


SWIGINTERN int OrderCategory_LINKED_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCategory_LINKED_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderCategory_LINKED_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCategory_LINKED_ORDER));
  return pyobj;
}


SWIGINTERN int AdvTransType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdvTransType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *AdvTransType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::AdvTransType_REPLACE);
  return pyobj;
}


SWIGINTERN int AdvTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdvTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *AdvTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::AdvTransType_NEW);
  return pyobj;
}


SWIGINTERN int AdvTransType_ADVCANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdvTransType_ADVCANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *AdvTransType_ADVCANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::AdvTransType_ADVCANCEL);
  return pyobj;
}


SWIGINTERN int AdvTransType_ADVREPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdvTransType_ADVREPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *AdvTransType_ADVREPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::AdvTransType_ADVREPLACE);
  return pyobj;
}


SWIGINTERN int AdvTransType_ADVNEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdvTransType_ADVNEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *AdvTransType_ADVNEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::AdvTransType_ADVNEW);
  return pyobj;
}


SWIGINTERN int AdvTransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdvTransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *AdvTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::AdvTransType_CANCEL);
  return pyobj;
}


SWIGINTERN int PublishTrdIndicator_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PublishTrdIndicator_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *PublishTrdIndicator_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PublishTrdIndicator_NO));
  return pyobj;
}


SWIGINTERN int PublishTrdIndicator_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PublishTrdIndicator_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *PublishTrdIndicator_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PublishTrdIndicator_YES));
  return pyobj;
}


SWIGINTERN int SecurityResponseType_ACCPTSECPROPREV_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityResponseType_ACCPTSECPROPREV is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityResponseType_ACCPTSECPROPREV_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityResponseType_ACCPTSECPROPREV));
  return pyobj;
}


SWIGINTERN int SecurityResponseType_SECLISTTYPESRET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityResponseType_SECLISTTYPESRET is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityResponseType_SECLISTTYPESRET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityResponseType_SECLISTTYPESRET));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 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 *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 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 *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 SecurityResponseType_ACCPTSECPROP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityResponseType_ACCPTSECPROP is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityResponseType_ACCPTSECPROP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityResponseType_ACCPTSECPROP));
  return pyobj;
}


SWIGINTERN int SecurityResponseType_REJECT_SECURITY_PROPOSAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityResponseType_REJECT_SECURITY_PROPOSAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SecurityResponseType_SECLISTRET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityResponseType_SECLISTRET is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityResponseType_SECLISTRET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityResponseType_SECLISTRET));
  return pyobj;
}


SWIGINTERN int SecurityResponseType_REJSECPROP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityResponseType_REJSECPROP is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityResponseType_REJSECPROP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityResponseType_REJSECPROP));
  return pyobj;
}


SWIGINTERN int 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 *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 SecurityResponseType_CANNOT_MATCH_SELECTION_CRITERIA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityResponseType_CANNOT_MATCH_SELECTION_CRITERIA is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SecurityResponseType_NOMATCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityResponseType_NOMATCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityResponseType_NOMATCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityResponseType_NOMATCH));
  return pyobj;
}


SWIGINTERN int SessionStatus_PASSWORD_EXPIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionStatus_PASSWORD_EXPIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *SessionStatus_PASSWORD_EXPIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionStatus_PASSWORD_EXPIRED));
  return pyobj;
}


SWIGINTERN int SessionStatus_SESSION_LOGOUT_COMPLETE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionStatus_SESSION_LOGOUT_COMPLETE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SessionStatus_INVALID_USERNAME_OR_PASSWORD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionStatus_INVALID_USERNAME_OR_PASSWORD is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SessionStatus_SESSION_ACTIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionStatus_SESSION_ACTIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SessionStatus_SESSION_ACTIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionStatus_SESSION_ACTIVE));
  return pyobj;
}


SWIGINTERN int SessionStatus_SESSION_PASSWORD_CHANGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionStatus_SESSION_PASSWORD_CHANGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SessionStatus_ACCOUNT_LOCKED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionStatus_ACCOUNT_LOCKED is read-only.");
  return 1;
}


SWIGINTERN PyObject *SessionStatus_ACCOUNT_LOCKED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionStatus_ACCOUNT_LOCKED));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 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 *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 AllocAccountType_JBO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocAccountType_JBO is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocAccountType_JBO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_JBO));
  return pyobj;
}


SWIGINTERN int AllocAccountType_HOUSE_TRADER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocAccountType_HOUSE_TRADER is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocAccountType_HOUSE_TRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_HOUSE_TRADER));
  return pyobj;
}


SWIGINTERN int 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 *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 AllocAccountType_FLOOR_TRADER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocAccountType_FLOOR_TRADER is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocAccountType_FLOOR_TRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_FLOOR_TRADER));
  return pyobj;
}


SWIGINTERN int AllocAccountType_ACCOUNTISHOUSETRADERANDISCROSSMARGINED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocAccountType_ACCOUNTISHOUSETRADERANDISCROSSMARGINED is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocAccountType_ACCOUNTISHOUSETRADERANDISCROSSMARGINED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_ACCOUNTISHOUSETRADERANDISCROSSMARGINED));
  return pyobj;
}


SWIGINTERN int AllocAccountType_ACCOUNTISCARRIEDONCUSTOMERSIDEOFBOOKS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocAccountType_ACCOUNTISCARRIEDONCUSTOMERSIDEOFBOOKS is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocAccountType_ACCOUNTISCARRIEDONCUSTOMERSIDEOFBOOKS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_ACCOUNTISCARRIEDONCUSTOMERSIDEOFBOOKS));
  return pyobj;
}


SWIGINTERN int AllocAccountType_JOINT_BACK_OFFICE_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocAccountType_JOINT_BACK_OFFICE_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 AllocAccountType_ACCOUNTISCARRIEDONNONCUSTOMERSIDEOFBOOKSANDISCROSSMARGINED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocAccountType_ACCOUNTISCARRIEDONNONCUSTOMERSIDEOFBOOKSANDISCROSSMARGINED is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocAccountType_ACCOUNTISCARRIEDONNONCUSTOMERSIDEOFBOOKSANDISCROSSMARGINED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_ACCOUNTISCARRIEDONNONCUSTOMERSIDEOFBOOKSANDISCROSSMARGINED));
  return pyobj;
}


SWIGINTERN int AllocAccountType_HOUSETRADER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocAccountType_HOUSETRADER is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocAccountType_HOUSETRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_HOUSETRADER));
  return pyobj;
}


SWIGINTERN int AllocAccountType_FLOORTRADER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocAccountType_FLOORTRADER is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocAccountType_FLOORTRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_FLOORTRADER));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 AllocAccountType_ACCOUNTISCARRIEDONNONCUSTOMERSIDEOFBOOKS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocAccountType_ACCOUNTISCARRIEDONNONCUSTOMERSIDEOFBOOKS is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocAccountType_ACCOUNTISCARRIEDONNONCUSTOMERSIDEOFBOOKS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_ACCOUNTISCARRIEDONNONCUSTOMERSIDEOFBOOKS));
  return pyobj;
}


SWIGINTERN int 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 *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 AllocTransType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocTransType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocTransType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocTransType_REPLACE));
  return pyobj;
}


SWIGINTERN int AllocTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocTransType_NEW));
  return pyobj;
}


SWIGINTERN int AllocTransType_CALCULATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocTransType_CALCULATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocTransType_CALCULATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocTransType_CALCULATED));
  return pyobj;
}


SWIGINTERN int AllocTransType_PRELIMINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocTransType_PRELIMINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocTransType_PRELIMINARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocTransType_PRELIMINARY));
  return pyobj;
}


SWIGINTERN int AllocTransType_CALCULATEDWITHOUTPRELIMINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocTransType_CALCULATEDWITHOUTPRELIMINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocTransType_CALCULATEDWITHOUTPRELIMINARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocTransType_CALCULATEDWITHOUTPRELIMINARY));
  return pyobj;
}


SWIGINTERN int AllocTransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocTransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocTransType_CANCEL));
  return pyobj;
}


SWIGINTERN int AllocTransType_REVERSAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocTransType_REVERSAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocTransType_REVERSAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocTransType_REVERSAL));
  return pyobj;
}


SWIGINTERN int AllocTransType_CALCULATED_WITHOUT_PRELIMINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocTransType_CALCULATED_WITHOUT_PRELIMINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExpirationQtyType_DIFFERENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpirationQtyType_DIFFERENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExpirationQtyType_DIFFERENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpirationQtyType_DIFFERENCE));
  return pyobj;
}


SWIGINTERN int ExpirationQtyType_FINAL_WILL_BE_EXERCISED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpirationQtyType_FINAL_WILL_BE_EXERCISED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExpirationQtyType_NON_AUTO_EXERCISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpirationQtyType_NON_AUTO_EXERCISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExpirationQtyType_CONTRARY_INTENTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpirationQtyType_CONTRARY_INTENTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExpirationQtyType_CONTRARY_INTENTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpirationQtyType_CONTRARY_INTENTION));
  return pyobj;
}


SWIGINTERN int ExpirationQtyType_AUTO_EXERCISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpirationQtyType_AUTO_EXERCISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExpirationQtyType_AUTO_EXERCISE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpirationQtyType_AUTO_EXERCISE));
  return pyobj;
}


SWIGINTERN int AllocHandlInst_FORWARDMATCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocHandlInst_FORWARDMATCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocHandlInst_FORWARDMATCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocHandlInst_FORWARDMATCH));
  return pyobj;
}


SWIGINTERN int AllocHandlInst_FORWARD_AND_MATCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocHandlInst_FORWARD_AND_MATCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 AllocHandlInst_FORWARD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocHandlInst_FORWARD is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocHandlInst_FORWARD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocHandlInst_FORWARD));
  return pyobj;
}


SWIGINTERN int AllocHandlInst_MATCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocHandlInst_MATCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocHandlInst_MATCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocHandlInst_MATCH));
  return pyobj;
}


SWIGINTERN int TradeRequestStatus_COMPLETED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestStatus_COMPLETED is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeRequestStatus_COMPLETED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestStatus_COMPLETED));
  return pyobj;
}


SWIGINTERN int TradeRequestStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeRequestStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int TradeRequestStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeRequestStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int 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 *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 PreallocMethod_PRO_RATA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PreallocMethod_PRO_RATA is read-only.");
  return 1;
}


SWIGINTERN PyObject *PreallocMethod_PRO_RATA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PreallocMethod_PRO_RATA));
  return pyobj;
}


SWIGINTERN int PreallocMethod_DO_NOT_PRORATA_DISCUSS_FIRST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PreallocMethod_DO_NOT_PRORATA_DISCUSS_FIRST is read-only.");
  return 1;
}


SWIGINTERN PyObject *PreallocMethod_DO_NOT_PRORATA_DISCUSS_FIRST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PreallocMethod_DO_NOT_PRORATA_DISCUSS_FIRST));
  return pyobj;
}


SWIGINTERN int PreallocMethod_DO_NOT_PRO_RATA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PreallocMethod_DO_NOT_PRO_RATA is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PreallocMethod_PRORATA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PreallocMethod_PRORATA is read-only.");
  return 1;
}


SWIGINTERN PyObject *PreallocMethod_PRORATA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PreallocMethod_PRORATA));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_ROTHIRANONPROTOTYPEUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_ROTHIRANONPROTOTYPEUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_ROTHIRANONPROTOTYPEUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_ROTHIRANONPROTOTYPEUS));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_INDIVIDUALRETIREMENTACCOUNTROLLOVERUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_INDIVIDUALRETIREMENTACCOUNTROLLOVERUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_INDIVIDUALRETIREMENTACCOUNTROLLOVERUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_INDIVIDUALRETIREMENTACCOUNTROLLOVERUS));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_PROFITSHARINGPLANUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_PROFITSHARINGPLANUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_PROFITSHARINGPLANUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_PROFITSHARINGPLANUS));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_SELF_DIRECTED_IRA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_SELF_DIRECTED_IRA is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TaxAdvantageType_401_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_401 is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_401_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_401));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_EMPLOYER_11_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_EMPLOYER_11 is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_EMPLOYER_11_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYER_11));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_457US_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_457US is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_457US_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_457US));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_EMPLOYER_12_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_EMPLOYER_12 is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_EMPLOYER_12_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYER_12));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_MINI_CASH_ISA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_MINI_CASH_ISA is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 TaxAdvantageType_ROTH_CONVERSION_IRA_26_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_ROTH_CONVERSION_IRA_26 is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TaxAdvantageType_EMPLOYEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_EMPLOYEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_EMPLOYEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYEE));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_SELFDIRECTEDIRAUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_SELFDIRECTEDIRAUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_SELFDIRECTEDIRAUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_SELFDIRECTEDIRAUS));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_403_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_403 is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_403_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_403));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_NON_FUND_PROTOTYPE_IRA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_NON_FUND_PROTOTYPE_IRA is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TaxAdvantageType_NONFUNDPROTOTYPEIRAUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_NONFUNDPROTOTYPEIRAUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_NONFUNDPROTOTYPEIRAUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_NONFUNDPROTOTYPEIRAUS));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_ROTH_CONVERSION_IRA_27_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_ROTH_CONVERSION_IRA_27 is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TaxAdvantageType_ROTHCONVERSIONIRANONPROTOTYPEUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_ROTHCONVERSIONIRANONPROTOTYPEUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_ROTHCONVERSIONIRANONPROTOTYPEUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_ROTHCONVERSIONIRANONPROTOTYPEUS));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_MINI_INSURANCE_ISA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_MINI_INSURANCE_ISA is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TaxAdvantageType_ROTHCONVERSIONIRAFUNDPROTOTYPEUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_ROTHCONVERSIONIRAFUNDPROTOTYPEUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_ROTHCONVERSIONIRAFUNDPROTOTYPEUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_ROTHCONVERSIONIRAFUNDPROTOTYPEUS));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_EDUCATIONIRAFUNDPROTOTYPEUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_EDUCATIONIRAFUNDPROTOTYPEUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_EDUCATIONIRAFUNDPROTOTYPEUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EDUCATIONIRAFUNDPROTOTYPEUS));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_MAXIISAUK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_MAXIISAUK is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_MAXIISAUK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_MAXIISAUK));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_ROLLOVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_ROLLOVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TaxAdvantageType_NONFUNDQUALIFIEDPLANUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_NONFUNDQUALIFIEDPLANUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_NONFUNDQUALIFIEDPLANUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_NONFUNDQUALIFIEDPLANUS));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_EMPLOYER_CURRENT_YEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_EMPLOYER_CURRENT_YEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TaxAdvantageType_PRIORYEARPAYMENTUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_PRIORYEARPAYMENTUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_PRIORYEARPAYMENTUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_PRIORYEARPAYMENTUS));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_TESSAUK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_TESSAUK is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_TESSAUK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_TESSAUK));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_CURRENTYEARPAYMENTUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_CURRENTYEARPAYMENTUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_CURRENTYEARPAYMENTUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_CURRENTYEARPAYMENTUS));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_EDUCATIONIRANONPROTOTYPEUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_EDUCATIONIRANONPROTOTYPEUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_EDUCATIONIRANONPROTOTYPEUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EDUCATIONIRANONPROTOTYPEUS));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_INDIVIDUALRETIREMENTACCOUNTUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_INDIVIDUALRETIREMENTACCOUNTUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_INDIVIDUALRETIREMENTACCOUNTUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_INDIVIDUALRETIREMENTACCOUNTUS));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_KEOGHUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_KEOGHUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_KEOGHUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_KEOGHUS));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_EDUCATION_IRA_28_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_EDUCATION_IRA_28 is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TaxAdvantageType_PROFIT_SHARING_PLAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_PROFIT_SHARING_PLAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TaxAdvantageType_NON_FUND_QUALIFIED_PLAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_NON_FUND_QUALIFIED_PLAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TaxAdvantageType_ROTHIRAFUNDPROTOTYPEUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_ROTHIRAFUNDPROTOTYPEUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_ROTHIRAFUNDPROTOTYPEUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_ROTHIRAFUNDPROTOTYPEUS));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_EDUCATION_IRA_29_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_EDUCATION_IRA_29 is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TaxAdvantageType_EMPLOYEE_10_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_EMPLOYEE_10 is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_EMPLOYEE_10_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYEE_10));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_EMPLOYEE_9_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_EMPLOYEE_9 is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_EMPLOYEE_9_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYEE_9));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_EMPLOYEE_CURRENT_YEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_EMPLOYEE_CURRENT_YEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TaxAdvantageType_MAXI_ISA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_MAXI_ISA is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_MAXI_ISA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_MAXI_ISA));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_MINIINSURANCEISAUK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_MINIINSURANCEISAUK is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_MINIINSURANCEISAUK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_MINIINSURANCEISAUK));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_PRIOR_YEAR_PAYMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_PRIOR_YEAR_PAYMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TaxAdvantageType_DEFINED_CONTRIBUTION_PLAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_DEFINED_CONTRIBUTION_PLAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TaxAdvantageType_401K_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_401K is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_401K_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_401K));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_403BUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_403BUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_403BUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_403BUS));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_MINICASHISAUK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_MINICASHISAUK is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_MINICASHISAUK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_MINICASHISAUK));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_ROTH_IRA_24_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_ROTH_IRA_24 is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TaxAdvantageType_MINISTOCKSANDSHARESISAUK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_MINISTOCKSANDSHARESISAUK is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_MINISTOCKSANDSHARESISAUK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_MINISTOCKSANDSHARESISAUK));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_OTHER));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_EMPLOYERCURRENTYEARUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_EMPLOYERCURRENTYEARUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_EMPLOYERCURRENTYEARUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYERCURRENTYEARUS));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_ASSET_TRANSFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_ASSET_TRANSFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_ASSET_TRANSFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_ASSET_TRANSFER));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_ROTH_IRA_25_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_ROTH_IRA_25 is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TaxAdvantageType_KEOGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_KEOGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_KEOGH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_KEOGH));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_DEFINEDCONTRIBUTIONPLANUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_DEFINEDCONTRIBUTIONPLANUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_DEFINEDCONTRIBUTIONPLANUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_DEFINEDCONTRIBUTIONPLANUS));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_401KUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_401KUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_401KUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_401KUS));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_TESSA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_TESSA is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_TESSA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_TESSA));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_NONE_NOT_APPLICABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_NONE_NOT_APPLICABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TaxAdvantageType_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_NONE));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_457_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_457 is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_457_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_457));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_EMPLOYEEPRIORYEARUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_EMPLOYEEPRIORYEARUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_EMPLOYEEPRIORYEARUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYEEPRIORYEARUS));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_EMPLOYERPRIORYEARUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_EMPLOYERPRIORYEARUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_EMPLOYERPRIORYEARUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYERPRIORYEARUS));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_EMPLOYER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_EMPLOYER is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_EMPLOYER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYER));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_EMPLOYEECURRENTYEARUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_EMPLOYEECURRENTYEARUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_EMPLOYEECURRENTYEARUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYEECURRENTYEARUS));
  return pyobj;
}


SWIGINTERN int TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_16_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_16 is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_17_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_17 is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TaxAdvantageType_CURRENT_YEAR_PAYMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_CURRENT_YEAR_PAYMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TaxAdvantageType_ASSETTRANSFERUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_ASSETTRANSFERUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TaxAdvantageType_ASSETTRANSFERUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_ASSETTRANSFERUS));
  return pyobj;
}


SWIGINTERN int MessageEncoding_EUC_JP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MessageEncoding_EUC_JP is read-only.");
  return 1;
}


SWIGINTERN PyObject *MessageEncoding_EUC_JP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MessageEncoding_EUC_JP);
  return pyobj;
}


SWIGINTERN int MessageEncoding_SHIFT_JIS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MessageEncoding_SHIFT_JIS is read-only.");
  return 1;
}


SWIGINTERN PyObject *MessageEncoding_SHIFT_JIS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MessageEncoding_SHIFT_JIS);
  return pyobj;
}


SWIGINTERN int MessageEncoding_UTF_8_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MessageEncoding_UTF_8 is read-only.");
  return 1;
}


SWIGINTERN PyObject *MessageEncoding_UTF_8_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MessageEncoding_UTF_8);
  return pyobj;
}


SWIGINTERN int MessageEncoding_ISO_2022_JP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MessageEncoding_ISO_2022_JP is read-only.");
  return 1;
}


SWIGINTERN PyObject *MessageEncoding_ISO_2022_JP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MessageEncoding_ISO_2022_JP);
  return pyobj;
}


SWIGINTERN int TimeInForce_GOOD_TILL_CROSSING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_GOOD_TILL_CROSSING is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TimeInForce_FILL_OR_KILL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_FILL_OR_KILL is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TimeInForce_GOOD_TILL_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_GOOD_TILL_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TimeInForce_ATTHEOPENING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_ATTHEOPENING is read-only.");
  return 1;
}


SWIGINTERN PyObject *TimeInForce_ATTHEOPENING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TimeInForce_ATTHEOPENING));
  return pyobj;
}


SWIGINTERN int TimeInForce_FILLORKILL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_FILLORKILL is read-only.");
  return 1;
}


SWIGINTERN PyObject *TimeInForce_FILLORKILL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TimeInForce_FILLORKILL));
  return pyobj;
}


SWIGINTERN int TimeInForce_GOODTILLDATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_GOODTILLDATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TimeInForce_GOODTILLDATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TimeInForce_GOODTILLDATE));
  return pyobj;
}


SWIGINTERN int TimeInForce_GOODTILLCANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_GOODTILLCANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *TimeInForce_GOODTILLCANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TimeInForce_GOODTILLCANCEL));
  return pyobj;
}


SWIGINTERN int TimeInForce_ATTHECLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_ATTHECLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TimeInForce_ATTHECLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TimeInForce_ATTHECLOSE));
  return pyobj;
}


SWIGINTERN int TimeInForce_GOOD_TILL_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_GOOD_TILL_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TimeInForce_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *TimeInForce_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TimeInForce_DAY));
  return pyobj;
}


SWIGINTERN int TimeInForce_AT_CROSSING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_AT_CROSSING is read-only.");
  return 1;
}


SWIGINTERN PyObject *TimeInForce_AT_CROSSING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TimeInForce_AT_CROSSING));
  return pyobj;
}


SWIGINTERN int TimeInForce_IMMEDIATEORCANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_IMMEDIATEORCANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *TimeInForce_IMMEDIATEORCANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TimeInForce_IMMEDIATEORCANCEL));
  return pyobj;
}


SWIGINTERN int TimeInForce_IMMEDIATE_OR_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_IMMEDIATE_OR_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TimeInForce_GOODTILLCROSSING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_GOODTILLCROSSING is read-only.");
  return 1;
}


SWIGINTERN PyObject *TimeInForce_GOODTILLCROSSING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TimeInForce_GOODTILLCROSSING));
  return pyobj;
}


SWIGINTERN int TimeInForce_GOOD_THROUGH_CROSSING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_GOOD_THROUGH_CROSSING is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TimeInForce_AT_THE_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_AT_THE_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TimeInForce_AT_THE_OPENING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_AT_THE_OPENING is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 IOIQualifier_AON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_AON is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIQualifier_AON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_AON));
  return pyobj;
}


SWIGINTERN int IOIQualifier_THROUGH_THE_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_THROUGH_THE_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 IOIQualifier_INDIDCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_INDIDCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIQualifier_INDIDCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_INDIDCATION));
  return pyobj;
}


SWIGINTERN int IOIQualifier_MOC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_MOC is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIQualifier_MOC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_MOC));
  return pyobj;
}


SWIGINTERN int IOIQualifier_READYTRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_READYTRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIQualifier_READYTRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_READYTRADE));
  return pyobj;
}


SWIGINTERN int IOIQualifier_ATMID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_ATMID is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIQualifier_ATMID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_ATMID));
  return pyobj;
}


SWIGINTERN int IOIQualifier_INDWRKAWAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_INDWRKAWAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIQualifier_INDWRKAWAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_INDWRKAWAY));
  return pyobj;
}


SWIGINTERN int IOIQualifier_AT_THE_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_AT_THE_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 IOIQualifier_AT_THE_MIDPOINT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_AT_THE_MIDPOINT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 IOIQualifier_CROSSING_OPPORTUNITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_CROSSING_OPPORTUNITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIQualifier_CROSSING_OPPORTUNITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_CROSSING_OPPORTUNITY));
  return pyobj;
}


SWIGINTERN int IOIQualifier_CURRENT_QUOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_CURRENT_QUOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIQualifier_CURRENT_QUOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_CURRENT_QUOTE));
  return pyobj;
}


SWIGINTERN int IOIQualifier_IN_TOUCH_WITH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_IN_TOUCH_WITH is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 IOIQualifier_ALL_OR_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_ALL_OR_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 IOIQualifier_THROUGHDAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_THROUGHDAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIQualifier_THROUGHDAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_THROUGHDAY));
  return pyobj;
}


SWIGINTERN int IOIQualifier_TAKING_A_POSITION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_TAKING_A_POSITION is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 IOIQualifier_AT_THE_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_AT_THE_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 IOIQualifier_TAKEPOSITION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_TAKEPOSITION is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIQualifier_TAKEPOSITION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_TAKEPOSITION));
  return pyobj;
}


SWIGINTERN int IOIQualifier_PORTFOLIO_SHOW_N_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_PORTFOLIO_SHOW_N is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 IOIQualifier_INTOUCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_INTOUCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIQualifier_INTOUCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_INTOUCH));
  return pyobj;
}


SWIGINTERN int IOIQualifier_MOREBEHIND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_MOREBEHIND is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIQualifier_MOREBEHIND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_MOREBEHIND));
  return pyobj;
}


SWIGINTERN int IOIQualifier_ATMARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_ATMARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIQualifier_ATMARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_ATMARKET));
  return pyobj;
}


SWIGINTERN int IOIQualifier_CROSSOPP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_CROSSOPP is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIQualifier_CROSSOPP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_CROSSOPP));
  return pyobj;
}


SWIGINTERN int IOIQualifier_PREOPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_PREOPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIQualifier_PREOPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_PREOPEN));
  return pyobj;
}


SWIGINTERN int IOIQualifier_ATCLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_ATCLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIQualifier_ATCLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_ATCLOSE));
  return pyobj;
}


SWIGINTERN int IOIQualifier_MARKET_ON_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_MARKET_ON_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 IOIQualifier_VERSUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_VERSUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIQualifier_VERSUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_VERSUS));
  return pyobj;
}


SWIGINTERN int IOIQualifier_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIQualifier_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_LIMIT));
  return pyobj;
}


SWIGINTERN int IOIQualifier_PORTFOLIO_SHOWN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_PORTFOLIO_SHOWN is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIQualifier_PORTFOLIO_SHOWN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_PORTFOLIO_SHOWN));
  return pyobj;
}


SWIGINTERN int IOIQualifier_READY_TO_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_READY_TO_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 IOIQualifier_PRE_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_PRE_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIQualifier_PRE_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_PRE_OPEN));
  return pyobj;
}


SWIGINTERN int IOIQualifier_INDICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_INDICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIQualifier_INDICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_INDICATION));
  return pyobj;
}


SWIGINTERN int IOIQualifier_MORE_BEHIND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_MORE_BEHIND is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIQualifier_MORE_BEHIND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_MORE_BEHIND));
  return pyobj;
}


SWIGINTERN int IOIQualifier_ATOPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_ATOPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIQualifier_ATOPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_ATOPEN));
  return pyobj;
}


SWIGINTERN int IOIQualifier_VWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_VWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIQualifier_VWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_VWAP));
  return pyobj;
}


SWIGINTERN int IOIQualifier_PORTSHOW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_PORTSHOW is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIQualifier_PORTSHOW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_PORTSHOW));
  return pyobj;
}


SWIGINTERN int IOIQualifier_AT_THE_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_AT_THE_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 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 *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 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 *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 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 *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 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 *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 MiscFeeType_CONVERSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_CONVERSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *MiscFeeType_CONVERSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_CONVERSION);
  return pyobj;
}


SWIGINTERN int MiscFeeType_CONSUMPTION_TAX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_CONSUMPTION_TAX is read-only.");
  return 1;
}


SWIGINTERN PyObject *MiscFeeType_CONSUMPTION_TAX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_CONSUMPTION_TAX);
  return pyobj;
}


SWIGINTERN int MiscFeeType_LOCAL_COMMISSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_LOCAL_COMMISSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *MiscFeeType_LOCAL_COMMISSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_LOCAL_COMMISSION);
  return pyobj;
}


SWIGINTERN int MiscFeeType_TAX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_TAX is read-only.");
  return 1;
}


SWIGINTERN PyObject *MiscFeeType_TAX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_TAX);
  return pyobj;
}


SWIGINTERN int MiscFeeType_LOCALCOMM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_LOCALCOMM is read-only.");
  return 1;
}


SWIGINTERN PyObject *MiscFeeType_LOCALCOMM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_LOCALCOMM);
  return pyobj;
}


SWIGINTERN int MiscFeeType_MARKUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_MARKUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *MiscFeeType_MARKUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_MARKUP);
  return pyobj;
}


SWIGINTERN int MiscFeeType_SECURITY_LENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_SECURITY_LENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *MiscFeeType_SECURITY_LENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_SECURITY_LENDING);
  return pyobj;
}


SWIGINTERN int MiscFeeType_PER_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_PER_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *MiscFeeType_PER_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_PER_TRANSACTION);
  return pyobj;
}


SWIGINTERN int MiscFeeType_REGULATORY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_REGULATORY is read-only.");
  return 1;
}


SWIGINTERN PyObject *MiscFeeType_REGULATORY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_REGULATORY);
  return pyobj;
}


SWIGINTERN int MiscFeeType_EXCHFEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_EXCHFEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MiscFeeType_EXCHFEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_EXCHFEE);
  return pyobj;
}


SWIGINTERN int MiscFeeType_CONSUMPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_CONSUMPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *MiscFeeType_CONSUMPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_CONSUMPTION);
  return pyobj;
}


SWIGINTERN int MiscFeeType_STAMP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_STAMP is read-only.");
  return 1;
}


SWIGINTERN PyObject *MiscFeeType_STAMP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_STAMP);
  return pyobj;
}


SWIGINTERN int MiscFeeType_TRANSFER_FEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_TRANSFER_FEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MiscFeeType_TRANSFER_FEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_TRANSFER_FEE);
  return pyobj;
}


SWIGINTERN int MiscFeeType_AGENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_AGENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *MiscFeeType_AGENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_AGENT);
  return pyobj;
}


SWIGINTERN int MiscFeeType_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *MiscFeeType_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_OTHER);
  return pyobj;
}


SWIGINTERN int MiscFeeType_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *MiscFeeType_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_TRANSACTION);
  return pyobj;
}


SWIGINTERN int MiscFeeType_REG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_REG is read-only.");
  return 1;
}


SWIGINTERN PyObject *MiscFeeType_REG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_REG);
  return pyobj;
}


SWIGINTERN int MiscFeeType_EXCHANGE_FEES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_EXCHANGE_FEES is read-only.");
  return 1;
}


SWIGINTERN PyObject *MiscFeeType_EXCHANGE_FEES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_EXCHANGE_FEES);
  return pyobj;
}


SWIGINTERN int MiscFeeType_LEVY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_LEVY is read-only.");
  return 1;
}


SWIGINTERN PyObject *MiscFeeType_LEVY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_LEVY);
  return pyobj;
}


SWIGINTERN int SecurityIDSource_CLEARING_HOUSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_CLEARING_HOUSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityIDSource_CLEARING_HOUSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_CLEARING_HOUSE);
  return pyobj;
}


SWIGINTERN int SecurityIDSource_OPTION_PRICE_REPORTING_AUTHORITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_OPTION_PRICE_REPORTING_AUTHORITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityIDSource_OPTION_PRICE_REPORTING_AUTHORITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_OPTION_PRICE_REPORTING_AUTHORITY);
  return pyobj;
}


SWIGINTERN int SecurityIDSource_EXCHANGE_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_EXCHANGE_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityIDSource_EXCHANGE_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_EXCHANGE_SYMBOL);
  return pyobj;
}


SWIGINTERN int SecurityIDSource_SICOVAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_SICOVAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityIDSource_SICOVAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_SICOVAM);
  return pyobj;
}


SWIGINTERN int SecurityIDSource_ISDA_FPML_PRODUCT_SPECIFICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_ISDA_FPML_PRODUCT_SPECIFICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityIDSource_ISDA_FPML_PRODUCT_SPECIFICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_ISDA_FPML_PRODUCT_SPECIFICATION);
  return pyobj;
}


SWIGINTERN int SecurityIDSource_ISDA_FPML_PRODUCT_URL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_ISDA_FPML_PRODUCT_URL is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityIDSource_ISDA_FPML_PRODUCT_URL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_ISDA_FPML_PRODUCT_URL);
  return pyobj;
}


SWIGINTERN int SecurityIDSource_RIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_RIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityIDSource_RIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_RIC);
  return pyobj;
}


SWIGINTERN int SecurityIDSource_CLEARINGHOUSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_CLEARINGHOUSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityIDSource_CLEARINGHOUSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_CLEARINGHOUSE);
  return pyobj;
}


SWIGINTERN int SecurityIDSource_FPML_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_FPML is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityIDSource_FPML_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_FPML);
  return pyobj;
}


SWIGINTERN int SecurityIDSource_RIC_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_RIC_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityIDSource_RIC_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_RIC_CODE);
  return pyobj;
}


SWIGINTERN int SecurityIDSource_ISOCURR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_ISOCURR is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityIDSource_ISOCURR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_ISOCURR);
  return pyobj;
}


SWIGINTERN int SecurityIDSource_ISO_CURRENCY_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_ISO_CURRENCY_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityIDSource_ISO_CURRENCY_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_ISO_CURRENCY_CODE);
  return pyobj;
}


SWIGINTERN int SecurityIDSource_COMMON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_COMMON is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityIDSource_COMMON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_COMMON);
  return pyobj;
}


SWIGINTERN int SecurityIDSource_VALOREN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_VALOREN is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityIDSource_VALOREN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_VALOREN);
  return pyobj;
}


SWIGINTERN int SecurityIDSource_BELGIAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_BELGIAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityIDSource_BELGIAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_BELGIAN);
  return pyobj;
}


SWIGINTERN int SecurityIDSource_CTA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_CTA is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityIDSource_CTA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_CTA);
  return pyobj;
}


SWIGINTERN int SecurityIDSource_ISIN_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_ISIN_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityIDSource_ISIN_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_ISIN_NUMBER);
  return pyobj;
}


SWIGINTERN int SecurityIDSource_ISIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_ISIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityIDSource_ISIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_ISIN);
  return pyobj;
}


SWIGINTERN int SecurityIDSource_ISOCOUNTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_ISOCOUNTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityIDSource_ISOCOUNTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_ISOCOUNTRY);
  return pyobj;
}


SWIGINTERN int SecurityIDSource_SEDOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_SEDOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityIDSource_SEDOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_SEDOL);
  return pyobj;
}


SWIGINTERN int SecurityIDSource_ISO_COUNTRY_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_ISO_COUNTRY_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityIDSource_ISO_COUNTRY_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_ISO_COUNTRY_CODE);
  return pyobj;
}


SWIGINTERN int SecurityIDSource_LETTER_OF_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_LETTER_OF_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityIDSource_LETTER_OF_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_LETTER_OF_CREDIT);
  return pyobj;
}


SWIGINTERN int SecurityIDSource_BLOOMBERG_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_BLOOMBERG_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityIDSource_BLOOMBERG_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_BLOOMBERG_SYMBOL);
  return pyobj;
}


SWIGINTERN int SecurityIDSource_BLMBRG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_BLMBRG is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityIDSource_BLMBRG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_BLMBRG);
  return pyobj;
}


SWIGINTERN int SecurityIDSource_OPTIONPRICEREPORTINGAUTHORITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_OPTIONPRICEREPORTINGAUTHORITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityIDSource_OPTIONPRICEREPORTINGAUTHORITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_OPTIONPRICEREPORTINGAUTHORITY);
  return pyobj;
}


SWIGINTERN int SecurityIDSource_WERTPAPIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_WERTPAPIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityIDSource_WERTPAPIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_WERTPAPIER);
  return pyobj;
}


SWIGINTERN int SecurityIDSource_MARKETPLACE_ASSIGNED_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_MARKETPLACE_ASSIGNED_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityIDSource_MARKETPLACE_ASSIGNED_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_MARKETPLACE_ASSIGNED_IDENTIFIER);
  return pyobj;
}


SWIGINTERN int SecurityIDSource_EXCHSYMB_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_EXCHSYMB is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityIDSource_EXCHSYMB_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_EXCHSYMB);
  return pyobj;
}


SWIGINTERN int SecurityIDSource_CONSOLIDATED_TAPE_ASSOCIATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_CONSOLIDATED_TAPE_ASSOCIATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityIDSource_CONSOLIDATED_TAPE_ASSOCIATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_CONSOLIDATED_TAPE_ASSOCIATION);
  return pyobj;
}


SWIGINTERN int SecurityIDSource_DUTCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_DUTCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityIDSource_DUTCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_DUTCH);
  return pyobj;
}


SWIGINTERN int SecurityIDSource_QUIK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_QUIK is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityIDSource_QUIK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_QUIK);
  return pyobj;
}


SWIGINTERN int SecurityIDSource_CUSIP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_CUSIP is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityIDSource_CUSIP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_CUSIP);
  return pyobj;
}


SWIGINTERN int NewsRefType_OTHER_LANGUAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NewsRefType_OTHER_LANGUAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *NewsRefType_OTHER_LANGUAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NewsRefType_OTHER_LANGUAGE));
  return pyobj;
}


SWIGINTERN int NewsRefType_COMPLIMENTARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NewsRefType_COMPLIMENTARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *NewsRefType_COMPLIMENTARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NewsRefType_COMPLIMENTARY));
  return pyobj;
}


SWIGINTERN int NewsRefType_REPLACEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NewsRefType_REPLACEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *NewsRefType_REPLACEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NewsRefType_REPLACEMENT));
  return pyobj;
}


SWIGINTERN int TriggerOrderType_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerOrderType_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *TriggerOrderType_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerOrderType_LIMIT));
  return pyobj;
}


SWIGINTERN int TriggerOrderType_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerOrderType_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *TriggerOrderType_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerOrderType_MARKET));
  return pyobj;
}


SWIGINTERN int CrossType_CROSS_AON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossType_CROSS_AON is read-only.");
  return 1;
}


SWIGINTERN PyObject *CrossType_CROSS_AON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSS_AON));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 CrossType_CROSSAON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossType_CROSSAON is read-only.");
  return 1;
}


SWIGINTERN PyObject *CrossType_CROSSAON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSSAON));
  return pyobj;
}


SWIGINTERN int 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 *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 CrossType_CROSS_ONE_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossType_CROSS_ONE_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 CrossType_CROSS_SAME_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossType_CROSS_SAME_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 CrossType_CROSSSAMEPRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossType_CROSSSAMEPRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *CrossType_CROSSSAMEPRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSSSAMEPRICE));
  return pyobj;
}


SWIGINTERN int CrossType_CROSS_IOC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossType_CROSS_IOC is read-only.");
  return 1;
}


SWIGINTERN PyObject *CrossType_CROSS_IOC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSS_IOC));
  return pyobj;
}


SWIGINTERN int CrossType_CROSSIOC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossType_CROSSIOC is read-only.");
  return 1;
}


SWIGINTERN PyObject *CrossType_CROSSIOC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSSIOC));
  return pyobj;
}


SWIGINTERN int CrossType_CROSSONESIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossType_CROSSONESIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *CrossType_CROSSONESIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSSONESIDE));
  return pyobj;
}


SWIGINTERN int 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 *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 OpenCloseSettleFlag_SESSION_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettleFlag_SESSION_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *OpenCloseSettleFlag_SESSION_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettleFlag_SESSION_OPEN));
  return pyobj;
}


SWIGINTERN int OpenCloseSettleFlag_DAILY_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettleFlag_DAILY_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *OpenCloseSettleFlag_DAILY_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettleFlag_DAILY_OPEN));
  return pyobj;
}


SWIGINTERN int OpenCloseSettleFlag_EXPECTED_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettleFlag_EXPECTED_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *OpenCloseSettleFlag_EXPECTED_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettleFlag_EXPECTED_PRICE));
  return pyobj;
}


SWIGINTERN int 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 *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 OpenCloseSettleFlag_DELIVERY_SETTLEMENT_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettleFlag_DELIVERY_SETTLEMENT_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MDBookType_PRICE_DEPTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDBookType_PRICE_DEPTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDBookType_PRICE_DEPTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDBookType_PRICE_DEPTH));
  return pyobj;
}


SWIGINTERN int MDBookType_ORDER_DEPTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDBookType_ORDER_DEPTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDBookType_ORDER_DEPTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDBookType_ORDER_DEPTH));
  return pyobj;
}


SWIGINTERN int MDBookType_TOP_OF_BOOK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDBookType_TOP_OF_BOOK is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 BasisPxType_VWAPAFT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_VWAPAFT is read-only.");
  return 1;
}


SWIGINTERN PyObject *BasisPxType_VWAPAFT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_VWAPAFT));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 BasisPxType_CLOSING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_CLOSING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *BasisPxType_CLOSING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_CLOSING_PRICE));
  return pyobj;
}


SWIGINTERN int BasisPxType_VWAP_THROUGH_A_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_VWAP_THROUGH_A_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 BasisPxType_CLOSING_PRICE_AT_MORNINGN_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_CLOSING_PRICE_AT_MORNINGN_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *BasisPxType_CLOSING_PRICE_AT_MORNINGN_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_CLOSING_PRICE_AT_MORNINGN_SESSION));
  return pyobj;
}


SWIGINTERN int BasisPxType_VWAPDAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_VWAPDAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *BasisPxType_VWAPDAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_VWAPDAY));
  return pyobj;
}


SWIGINTERN int BasisPxType_VWAPMORNXYORI_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_VWAPMORNXYORI is read-only.");
  return 1;
}


SWIGINTERN PyObject *BasisPxType_VWAPMORNXYORI_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_VWAPMORNXYORI));
  return pyobj;
}


SWIGINTERN int BasisPxType_VWAPMORN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_VWAPMORN is read-only.");
  return 1;
}


SWIGINTERN PyObject *BasisPxType_VWAPMORN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_VWAPMORN));
  return pyobj;
}


SWIGINTERN int BasisPxType_VWAPDAYXYORI_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_VWAPDAYXYORI is read-only.");
  return 1;
}


SWIGINTERN PyObject *BasisPxType_VWAPDAYXYORI_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_VWAPDAYXYORI));
  return pyobj;
}


SWIGINTERN int BasisPxType_OTHERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_OTHERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *BasisPxType_OTHERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_OTHERS));
  return pyobj;
}


SWIGINTERN int BasisPxType_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *BasisPxType_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_OPEN));
  return pyobj;
}


SWIGINTERN int BasisPxType_CURRPX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_CURRPX is read-only.");
  return 1;
}


SWIGINTERN PyObject *BasisPxType_CURRPX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_CURRPX));
  return pyobj;
}


SWIGINTERN int BasisPxType_VWAPAFTXYORI_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_VWAPAFTXYORI is read-only.");
  return 1;
}


SWIGINTERN PyObject *BasisPxType_VWAPAFTXYORI_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_VWAPAFTXYORI));
  return pyobj;
}


SWIGINTERN int 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 *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 BasisPxType_CLSPXMORN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_CLSPXMORN is read-only.");
  return 1;
}


SWIGINTERN PyObject *BasisPxType_CLSPXMORN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_CLSPXMORN));
  return pyobj;
}


SWIGINTERN int BasisPxType_CURRENT_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_CURRENT_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *BasisPxType_CURRENT_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_CURRENT_PRICE));
  return pyobj;
}


SWIGINTERN int BasisPxType_SQ_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_SQ is read-only.");
  return 1;
}


SWIGINTERN PyObject *BasisPxType_SQ_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_SQ));
  return pyobj;
}


SWIGINTERN int BasisPxType_CLSPX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_CLSPX is read-only.");
  return 1;
}


SWIGINTERN PyObject *BasisPxType_CLSPX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_CLSPX));
  return pyobj;
}


SWIGINTERN int BasisPxType_STRIKE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_STRIKE is read-only.");
  return 1;
}


SWIGINTERN PyObject *BasisPxType_STRIKE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_STRIKE));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 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 *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 ComplexEventType_ROLLING_BARRIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_ROLLING_BARRIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *ComplexEventType_ROLLING_BARRIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_ROLLING_BARRIER));
  return pyobj;
}


SWIGINTERN int ComplexEventType_UNDERLYING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_UNDERLYING is read-only.");
  return 1;
}


SWIGINTERN PyObject *ComplexEventType_UNDERLYING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_UNDERLYING));
  return pyobj;
}


SWIGINTERN int ComplexEventType_KNOCK_OUT_UP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_KNOCK_OUT_UP is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ComplexEventType_KNOCK_IN_UP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_KNOCK_IN_UP is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ComplexEventType_KOCK_IN_DOWN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_KOCK_IN_DOWN is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ComplexEventType_TRIGGER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_TRIGGER is read-only.");
  return 1;
}


SWIGINTERN PyObject *ComplexEventType_TRIGGER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_TRIGGER));
  return pyobj;
}


SWIGINTERN int ComplexEventType_RESET_BARRIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_RESET_BARRIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *ComplexEventType_RESET_BARRIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_RESET_BARRIER));
  return pyobj;
}


SWIGINTERN int ComplexEventType_CAPPED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_CAPPED is read-only.");
  return 1;
}


SWIGINTERN PyObject *ComplexEventType_CAPPED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_CAPPED));
  return pyobj;
}


SWIGINTERN int ComplexEventType_KNOCK_OUT_DOWN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_KNOCK_OUT_DOWN is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MassActionResponse_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionResponse_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassActionResponse_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionResponse_REJECTED));
  return pyobj;
}


SWIGINTERN int MassActionResponse_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionResponse_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassActionResponse_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionResponse_ACCEPTED));
  return pyobj;
}


SWIGINTERN int 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 *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 SecurityRequestType_REQUEST_LIST_SECURITY_TYPES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestType_REQUEST_LIST_SECURITY_TYPES is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SecurityRequestType_REQSECIDPROV_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestType_REQSECIDPROV is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityRequestType_REQSECIDPROV_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_REQSECIDPROV));
  return pyobj;
}


SWIGINTERN int SecurityRequestType_REQUEST_LIST_SECURITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestType_REQUEST_LIST_SECURITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SecurityRequestType_REQSECID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestType_REQSECID is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityRequestType_REQSECID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_REQSECID));
  return pyobj;
}


SWIGINTERN int SecurityRequestType_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestType_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityRequestType_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_SYMBOL));
  return pyobj;
}


SWIGINTERN int SecurityRequestType_SECURITYTYPE_AND_OR_CFICODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestType_SECURITYTYPE_AND_OR_CFICODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 SecurityRequestType_REQSECLIST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestType_REQSECLIST is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityRequestType_REQSECLIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_REQSECLIST));
  return pyobj;
}


SWIGINTERN int SecurityRequestType_TRADINGSESSIONID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestType_TRADINGSESSIONID is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityRequestType_TRADINGSESSIONID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_TRADINGSESSIONID));
  return pyobj;
}


SWIGINTERN int SecurityRequestType_PRODUCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestType_PRODUCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityRequestType_PRODUCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_PRODUCT));
  return pyobj;
}


SWIGINTERN int SecurityRequestType_ALL_SECURITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestType_ALL_SECURITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityRequestType_ALL_SECURITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_ALL_SECURITIES));
  return pyobj;
}


SWIGINTERN int SecurityRequestType_REQSECLISTTYPES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestType_REQSECLISTTYPES is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityRequestType_REQSECLISTTYPES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_REQSECLISTTYPES));
  return pyobj;
}


SWIGINTERN int 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 *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 ListRejectReason_EXCHANGE_CLOSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListRejectReason_EXCHANGE_CLOSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListRejectReason_EXCHANGE_CLOSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListRejectReason_EXCHANGE_CLOSED));
  return pyobj;
}


SWIGINTERN int ListRejectReason_UNKNOWN_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListRejectReason_UNKNOWN_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListRejectReason_UNKNOWN_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListRejectReason_UNKNOWN_ORDER));
  return pyobj;
}


SWIGINTERN int ListRejectReason_UNSUPPORTED_ORDER_CHARACTERISTIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListRejectReason_UNSUPPORTED_ORDER_CHARACTERISTIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ListRejectReason_DUPLICATE_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListRejectReason_DUPLICATE_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListRejectReason_DUPLICATE_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListRejectReason_DUPLICATE_ORDER));
  return pyobj;
}


SWIGINTERN int ListRejectReason_TOO_LATE_TO_ENTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListRejectReason_TOO_LATE_TO_ENTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ListRejectReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListRejectReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListRejectReason_OTHER));
  return pyobj;
}


SWIGINTERN int ListRejectReason_BROKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListRejectReason_BROKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListRejectReason_BROKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListRejectReason_BROKER));
  return pyobj;
}


SWIGINTERN int DeskType_PROPRIETARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_PROPRIETARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskType_PROPRIETARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_PROPRIETARY);
  return pyobj;
}


SWIGINTERN int DeskType_ARBITRAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_ARBITRAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskType_ARBITRAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_ARBITRAGE);
  return pyobj;
}


SWIGINTERN int DeskType_TRADING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_TRADING is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskType_TRADING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_TRADING);
  return pyobj;
}


SWIGINTERN int DeskType_DERIVATIVES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_DERIVATIVES is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskType_DERIVATIVES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_DERIVATIVES);
  return pyobj;
}


SWIGINTERN int DeskType_SALES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_SALES is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskType_SALES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_SALES);
  return pyobj;
}


SWIGINTERN int DeskType_INSTITUTIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_INSTITUTIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskType_INSTITUTIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_INSTITUTIONAL);
  return pyobj;
}


SWIGINTERN int DeskType_INTERNATIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_INTERNATIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskType_INTERNATIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_INTERNATIONAL);
  return pyobj;
}


SWIGINTERN int DeskType_AGENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_AGENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskType_AGENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_AGENCY);
  return pyobj;
}


SWIGINTERN int DeskType_PREFERRED_TRADING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_PREFERRED_TRADING is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskType_PREFERRED_TRADING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_PREFERRED_TRADING);
  return pyobj;
}


SWIGINTERN int DeskType_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskType_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_OTHER);
  return pyobj;
}


SWIGINTERN int DeskType_PROGRAM_TRADING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_PROGRAM_TRADING is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskType_PROGRAM_TRADING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_PROGRAM_TRADING);
  return pyobj;
}


SWIGINTERN int SettlType_T4_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_T4 is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlType_T4_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_T4);
  return pyobj;
}


SWIGINTERN int SettlType_T5_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_T5 is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlType_T5_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_T5);
  return pyobj;
}


SWIGINTERN int SettlType_WHEN_AND_IF_ISSUED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_WHEN_AND_IF_ISSUED is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlType_WHEN_AND_IF_ISSUED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_WHEN_AND_IF_ISSUED);
  return pyobj;
}


SWIGINTERN int SettlType_NEXTDAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_NEXTDAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlType_NEXTDAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_NEXTDAY);
  return pyobj;
}


SWIGINTERN int SettlType_FUTURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_FUTURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlType_FUTURE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_FUTURE);
  return pyobj;
}


SWIGINTERN int SettlType_T_PLUS_2_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_T_PLUS_2 is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlType_T_PLUS_2_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_T_PLUS_2);
  return pyobj;
}


SWIGINTERN int SettlType_SELLERS_OPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_SELLERS_OPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlType_SELLERS_OPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_SELLERS_OPTION);
  return pyobj;
}


SWIGINTERN int SettlType_BROKEN_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_BROKEN_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlType_BROKEN_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_BROKEN_DATE);
  return pyobj;
}


SWIGINTERN int SettlType_T_PLUS_3_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_T_PLUS_3 is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlType_T_PLUS_3_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_T_PLUS_3);
  return pyobj;
}


SWIGINTERN int SettlType_T_PLUS_4_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_T_PLUS_4 is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlType_T_PLUS_4_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_T_PLUS_4);
  return pyobj;
}


SWIGINTERN int SettlType_REGULAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_REGULAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlType_REGULAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_REGULAR);
  return pyobj;
}


SWIGINTERN int SettlType_NEXT_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_NEXT_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlType_NEXT_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_NEXT_DAY);
  return pyobj;
}


SWIGINTERN int SettlType_T_PLUS_5_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_T_PLUS_5 is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlType_T_PLUS_5_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_T_PLUS_5);
  return pyobj;
}


SWIGINTERN int SettlType_FX_SPOT_NEXT_SETTLEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_FX_SPOT_NEXT_SETTLEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlType_FX_SPOT_NEXT_SETTLEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_FX_SPOT_NEXT_SETTLEMENT);
  return pyobj;
}


SWIGINTERN int SettlType_T1_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_T1 is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlType_T1_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_T1);
  return pyobj;
}


SWIGINTERN int SettlType_WHENISSUED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_WHENISSUED is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlType_WHENISSUED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_WHENISSUED);
  return pyobj;
}


SWIGINTERN int SettlType_T2_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_T2 is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlType_T2_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_T2);
  return pyobj;
}


SWIGINTERN int SettlType_T3_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_T3 is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlType_T3_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_T3);
  return pyobj;
}


SWIGINTERN int SettlType_CASH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_CASH is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlType_CASH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_CASH);
  return pyobj;
}


SWIGINTERN int OpenClose_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenClose_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *OpenClose_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenClose_CLOSE));
  return pyobj;
}


SWIGINTERN int OpenClose_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenClose_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *OpenClose_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenClose_OPEN));
  return pyobj;
}


SWIGINTERN int ContractMultiplierUnit_SHARES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContractMultiplierUnit_SHARES is read-only.");
  return 1;
}


SWIGINTERN PyObject *ContractMultiplierUnit_SHARES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContractMultiplierUnit_SHARES));
  return pyobj;
}


SWIGINTERN int ContractMultiplierUnit_HOURS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContractMultiplierUnit_HOURS is read-only.");
  return 1;
}


SWIGINTERN PyObject *ContractMultiplierUnit_HOURS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContractMultiplierUnit_HOURS));
  return pyobj;
}


SWIGINTERN int ContractMultiplierUnit_DAYS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContractMultiplierUnit_DAYS is read-only.");
  return 1;
}


SWIGINTERN PyObject *ContractMultiplierUnit_DAYS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContractMultiplierUnit_DAYS));
  return pyobj;
}


SWIGINTERN int TrdType_VOLUME_WEIGHTED_AVERAGE_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_VOLUME_WEIGHTED_AVERAGE_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdType_LATE_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_LATE_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdType_LATE_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_LATE_TRADE));
  return pyobj;
}


SWIGINTERN int TrdType_FUTURES_LARGE_ORDER_EXECUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_FUTURES_LARGE_ORDER_EXECUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 TrdType_SPECIAL_EX_CAPITAL_REPAYMENTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_EX_CAPITAL_REPAYMENTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdType_BLOCK_TRADE_38_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_BLOCK_TRADE_38 is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdType_DELTA_NEUTRAL_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_DELTA_NEUTRAL_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdType_CASH_SETTLEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_CASH_SETTLEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdType_CASH_SETTLEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_CASH_SETTLEMENT));
  return pyobj;
}


SWIGINTERN int TrdType_SPECIAL_CUM_CAPITAL_REPAYMENTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_CUM_CAPITAL_REPAYMENTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdType_SPECIAL_CUM_BONUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_CUM_BONUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdType_BLOCK_TRADES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_BLOCK_TRADES is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdType_BLOCK_TRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_BLOCK_TRADES));
  return pyobj;
}


SWIGINTERN int TrdType_ALL_OR_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_ALL_OR_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdType_OPTION_EXERCISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_OPTION_EXERCISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdType_OPTION_EXERCISE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_OPTION_EXERCISE));
  return pyobj;
}


SWIGINTERN int TrdType_FINANCING_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_FINANCING_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdType_FINANCING_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_FINANCING_TRANSACTION));
  return pyobj;
}


SWIGINTERN int TrdType_TRANSFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_TRANSFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdType_TRANSFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_TRANSFER));
  return pyobj;
}


SWIGINTERN int TrdType_REGULAR_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_REGULAR_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdType_REGULAR_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_REGULAR_TRADE));
  return pyobj;
}


SWIGINTERN int TrdType_TRADING_AT_SETTLEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_TRADING_AT_SETTLEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdType_SPECIAL_EX_DIVIDEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_EX_DIVIDEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdType_SPECIAL_EX_COUPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_EX_COUPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdType_SPECIAL_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdType_SPECIAL_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_PRICE));
  return pyobj;
}


SWIGINTERN int TrdType_SPECIAL_CUM_RIGHTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_CUM_RIGHTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdType_SPECIAL_EX_BONUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_EX_BONUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdType_BLOCKTRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_BLOCKTRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdType_BLOCKTRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_BLOCKTRADE));
  return pyobj;
}


SWIGINTERN int TrdType_EXCHANGE_GRANTED_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_EXCHANGE_GRANTED_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdType_EXCHANGE_BASIS_FACILITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_EXCHANGE_BASIS_FACILITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdType_BLOCK_TRADE_1_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_BLOCK_TRADE_1 is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdType_LATE_BUNCHED_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_LATE_BUNCHED_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdType_ERROR_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_ERROR_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdType_ERROR_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_ERROR_TRADE));
  return pyobj;
}


SWIGINTERN int TrdType_NAME_CHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_NAME_CHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdType_NAME_CHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_NAME_CHANGE));
  return pyobj;
}


SWIGINTERN int TrdType_LATEBUNCHEDTRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_LATEBUNCHEDTRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdType_LATEBUNCHEDTRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_LATEBUNCHEDTRADE));
  return pyobj;
}


SWIGINTERN int TrdType_EFP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_EFP is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdType_EFP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_EFP));
  return pyobj;
}


SWIGINTERN int TrdType_NON_STANDARD_SETTLEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_NON_STANDARD_SETTLEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdType_PRIOR_REFERENCE_PRICE_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_PRIOR_REFERENCE_PRICE_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdType_EXCHANGE_FOR_RISK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_EXCHANGE_FOR_RISK is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdType_EXCHANGE_FOR_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_EXCHANGE_FOR_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdType_EXCHANGE_OF_FUTURES_FOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_EXCHANGE_OF_FUTURES_FOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdType_OPTION_INTERIM_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_OPTION_INTERIM_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdType_PRIVATELY_NEGOTIATED_TRADES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_PRIVATELY_NEGOTIATED_TRADES is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 TrdType_SPECIAL_CUM_DIVIDEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_CUM_DIVIDEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdType_GUARANTEED_DELIVERY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_GUARANTEED_DELIVERY is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdType_GUARANTEED_DELIVERY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_GUARANTEED_DELIVERY));
  return pyobj;
}


SWIGINTERN int TrdType_PROROGATION_SELL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_PROROGATION_SELL is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdType_PROROGATION_SELL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_PROROGATION_SELL));
  return pyobj;
}


SWIGINTERN int TrdType_WEIGHTEDAVERAGEPRICETRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_WEIGHTEDAVERAGEPRICETRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdType_WEIGHTEDAVERAGEPRICETRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_WEIGHTEDAVERAGEPRICETRADE));
  return pyobj;
}


SWIGINTERN int TrdType_PORTFOLIO_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_PORTFOLIO_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdType_PORTFOLIO_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_PORTFOLIO_TRADE));
  return pyobj;
}


SWIGINTERN int TrdType_WEIGHTED_AVERAGE_PRICE_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_WEIGHTED_AVERAGE_PRICE_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdType_WORKED_PRINCIPAL_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_WORKED_PRINCIPAL_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdType_PORTFOLIO_TRANSFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_PORTFOLIO_TRANSFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdType_PORTFOLIO_TRANSFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_PORTFOLIO_TRANSFER));
  return pyobj;
}


SWIGINTERN int TrdType_T_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_T_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdType_T_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_T_TRADE));
  return pyobj;
}


SWIGINTERN int 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 *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 TrdType_SPECIAL_CUM_COUPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_CUM_COUPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdType_BUNCHEDTRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_BUNCHEDTRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdType_BUNCHEDTRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_BUNCHEDTRADE));
  return pyobj;
}


SWIGINTERN int TrdType_TTRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_TTRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdType_TTRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_TTRADE));
  return pyobj;
}


SWIGINTERN int TrdType_OTC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_OTC is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdType_OTC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_OTC));
  return pyobj;
}


SWIGINTERN int TrdType_AFTER_HOURS_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_AFTER_HOURS_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdType_PRIORREFERENCEPRICETRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_PRIORREFERENCEPRICETRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdType_PRIORREFERENCEPRICETRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_PRIORREFERENCEPRICETRADE));
  return pyobj;
}


SWIGINTERN int TrdType_AFTERHOURSTRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_AFTERHOURSTRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdType_AFTERHOURSTRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_AFTERHOURSTRADE));
  return pyobj;
}


SWIGINTERN int TrdType_DERIVATIVE_RELATED_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_DERIVATIVE_RELATED_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdType_REPURCHASE_AGREEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_REPURCHASE_AGREEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdType_REPURCHASE_AGREEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_REPURCHASE_AGREEMENT));
  return pyobj;
}


SWIGINTERN int TrdType_SPECIAL_EX_RIGHTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_EX_RIGHTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdType_PROROGATION_BUY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_PROROGATION_BUY is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdType_PROROGATION_BUY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_PROROGATION_BUY));
  return pyobj;
}


SWIGINTERN int TrdType_BUNCHED_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_BUNCHED_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdType_BUNCHED_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_BUNCHED_TRADE));
  return pyobj;
}


SWIGINTERN int TrdType_OPTION_CABINET_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_OPTION_CABINET_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdType_LATETRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_LATETRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdType_LATETRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_LATETRADE));
  return pyobj;
}


SWIGINTERN int TrdType_REGULARTRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_REGULARTRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdType_REGULARTRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_REGULARTRADE));
  return pyobj;
}


SWIGINTERN int RestructuringType_MODIFIED_MOD_RESTRUCTURING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RestructuringType_MODIFIED_MOD_RESTRUCTURING is read-only.");
  return 1;
}


SWIGINTERN PyObject *RestructuringType_MODIFIED_MOD_RESTRUCTURING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::RestructuringType_MODIFIED_MOD_RESTRUCTURING);
  return pyobj;
}


SWIGINTERN int RestructuringType_FULL_RESTRUCTURING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RestructuringType_FULL_RESTRUCTURING is read-only.");
  return 1;
}


SWIGINTERN PyObject *RestructuringType_FULL_RESTRUCTURING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::RestructuringType_FULL_RESTRUCTURING);
  return pyobj;
}


SWIGINTERN int RestructuringType_NO_RESTRUCTURING_SPECIFIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RestructuringType_NO_RESTRUCTURING_SPECIFIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *RestructuringType_NO_RESTRUCTURING_SPECIFIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::RestructuringType_NO_RESTRUCTURING_SPECIFIED);
  return pyobj;
}


SWIGINTERN int RestructuringType_MODIFIED_RESTRUCTURING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RestructuringType_MODIFIED_RESTRUCTURING is read-only.");
  return 1;
}


SWIGINTERN PyObject *RestructuringType_MODIFIED_RESTRUCTURING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::RestructuringType_MODIFIED_RESTRUCTURING);
  return pyobj;
}


SWIGINTERN int ProgRptReqs_SELLSIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProgRptReqs_SELLSIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ProgRptReqs_SELLSIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProgRptReqs_SELLSIDE));
  return pyobj;
}


SWIGINTERN int ProgRptReqs_REALTIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProgRptReqs_REALTIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *ProgRptReqs_REALTIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProgRptReqs_REALTIME));
  return pyobj;
}


SWIGINTERN int ProgRptReqs_REAL_TIME_EXECUTION_REPORTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProgRptReqs_REAL_TIME_EXECUTION_REPORTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 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 *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 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 *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 ProgRptReqs_BUYSIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProgRptReqs_BUYSIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ProgRptReqs_BUYSIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProgRptReqs_BUYSIDE));
  return pyobj;
}


SWIGINTERN int 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 *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 TradingSessionID_EVENING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionID_EVENING is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradingSessionID_EVENING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionID_EVENING);
  return pyobj;
}


SWIGINTERN int TradingSessionID_AFTER_HOURS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionID_AFTER_HOURS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradingSessionID_AFTER_HOURS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionID_AFTER_HOURS);
  return pyobj;
}


SWIGINTERN int TradingSessionID_HALFDAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionID_HALFDAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradingSessionID_HALFDAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionID_HALFDAY);
  return pyobj;
}


SWIGINTERN int TradingSessionID_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionID_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradingSessionID_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionID_DAY);
  return pyobj;
}


SWIGINTERN int TradingSessionID_MORNING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionID_MORNING is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradingSessionID_MORNING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionID_MORNING);
  return pyobj;
}


SWIGINTERN int TradingSessionID_AFTERNOON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionID_AFTERNOON is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradingSessionID_AFTERNOON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionID_AFTERNOON);
  return pyobj;
}


SWIGINTERN int ListOrderStatus_RECVFOREXEC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_RECVFOREXEC is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListOrderStatus_RECVFOREXEC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_RECVFOREXEC));
  return pyobj;
}


SWIGINTERN int ListOrderStatus_CXL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_CXL is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListOrderStatus_CXL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_CXL));
  return pyobj;
}


SWIGINTERN int ListOrderStatus_REJ_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_REJ is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListOrderStatus_REJ_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_REJ));
  return pyobj;
}


SWIGINTERN int ListOrderStatus_CANCELING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_CANCELING is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListOrderStatus_CANCELING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_CANCELING));
  return pyobj;
}


SWIGINTERN int ListOrderStatus_REJECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_REJECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListOrderStatus_REJECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_REJECT));
  return pyobj;
}


SWIGINTERN int ListOrderStatus_ALL_DONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_ALL_DONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListOrderStatus_ALL_DONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_ALL_DONE));
  return pyobj;
}


SWIGINTERN int ListOrderStatus_INBIDPROC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_INBIDPROC is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListOrderStatus_INBIDPROC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_INBIDPROC));
  return pyobj;
}


SWIGINTERN int ListOrderStatus_ALLDONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_ALLDONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListOrderStatus_ALLDONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_ALLDONE));
  return pyobj;
}


SWIGINTERN int ListOrderStatus_IN_BIDDING_PROCESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_IN_BIDDING_PROCESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ListOrderStatus_RECEIVED_FOR_EXECUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_RECEIVED_FOR_EXECUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ListOrderStatus_ALERT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_ALERT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListOrderStatus_ALERT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_ALERT));
  return pyobj;
}


SWIGINTERN int ListOrderStatus_RECEIVEDFOREXECUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_RECEIVEDFOREXECUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListOrderStatus_RECEIVEDFOREXECUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_RECEIVEDFOREXECUTION));
  return pyobj;
}


SWIGINTERN int ListOrderStatus_INBIDDINGPROCESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_INBIDDINGPROCESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListOrderStatus_INBIDDINGPROCESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_INBIDDINGPROCESS));
  return pyobj;
}


SWIGINTERN int ListOrderStatus_EXEC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_EXEC is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListOrderStatus_EXEC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_EXEC));
  return pyobj;
}


SWIGINTERN int ListOrderStatus_CANCELLING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_CANCELLING is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListOrderStatus_CANCELLING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_CANCELLING));
  return pyobj;
}


SWIGINTERN int ListOrderStatus_EXECUTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_EXECUTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListOrderStatus_EXECUTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_EXECUTING));
  return pyobj;
}


SWIGINTERN int RegistStatus_REJECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistStatus_REJECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *RegistStatus_REJECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RegistStatus_REJECT));
  return pyobj;
}


SWIGINTERN int 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 *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 RegistStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *RegistStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RegistStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int RegistStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *RegistStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RegistStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int RegistStatus_REMINDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistStatus_REMINDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *RegistStatus_REMINDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RegistStatus_REMINDER));
  return pyobj;
}


SWIGINTERN int RegistStatus_HELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistStatus_HELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *RegistStatus_HELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RegistStatus_HELD));
  return pyobj;
}


SWIGINTERN int RegistStatus_ACCEPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistStatus_ACCEPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *RegistStatus_ACCEPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RegistStatus_ACCEPT));
  return pyobj;
}


SWIGINTERN int UnderlyingPriceDeterminationMethod_OPTIMAL_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingPriceDeterminationMethod_OPTIMAL_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *UnderlyingPriceDeterminationMethod_OPTIMAL_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UnderlyingPriceDeterminationMethod_OPTIMAL_VALUE));
  return pyobj;
}


SWIGINTERN int UnderlyingPriceDeterminationMethod_SPECIAL_REFERENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingPriceDeterminationMethod_SPECIAL_REFERENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *UnderlyingPriceDeterminationMethod_SPECIAL_REFERENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UnderlyingPriceDeterminationMethod_SPECIAL_REFERENCE));
  return pyobj;
}


SWIGINTERN int UnderlyingPriceDeterminationMethod_AVERAGE_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingPriceDeterminationMethod_AVERAGE_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *UnderlyingPriceDeterminationMethod_AVERAGE_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UnderlyingPriceDeterminationMethod_AVERAGE_VALUE));
  return pyobj;
}


SWIGINTERN int UnderlyingPriceDeterminationMethod_REGULAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingPriceDeterminationMethod_REGULAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *UnderlyingPriceDeterminationMethod_REGULAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UnderlyingPriceDeterminationMethod_REGULAR));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 MassCancelRequestType_CXLORDERSSECURITYTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CXLORDERSSECURITYTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassCancelRequestType_CXLORDERSSECURITYTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CXLORDERSSECURITYTYPE));
  return pyobj;
}


SWIGINTERN int MassCancelRequestType_CXLORDERSUNDERLYINGSECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CXLORDERSUNDERLYINGSECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassCancelRequestType_CXLORDERSUNDERLYINGSECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CXLORDERSUNDERLYINGSECURITY));
  return pyobj;
}


SWIGINTERN int MassCancelRequestType_CXLORDERSTRDSESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CXLORDERSTRDSESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassCancelRequestType_CXLORDERSTRDSESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CXLORDERSTRDSESSION));
  return pyobj;
}


SWIGINTERN int MassCancelRequestType_CXLALLORDERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CXLALLORDERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassCancelRequestType_CXLALLORDERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CXLALLORDERS));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 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 *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 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 *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 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 *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 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 *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 MassCancelRequestType_CXLORDERSSECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CXLORDERSSECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassCancelRequestType_CXLORDERSSECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CXLORDERSSECURITY));
  return pyobj;
}


SWIGINTERN int MassCancelRequestType_CXLORDERSPRODUCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CXLORDERSPRODUCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassCancelRequestType_CXLORDERSPRODUCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CXLORDERSPRODUCT));
  return pyobj;
}


SWIGINTERN int MassCancelRequestType_CANCEL_ALL_ORDERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CANCEL_ALL_ORDERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MassCancelRequestType_CANCEL_FOR_SECURITY_ISSUER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CANCEL_FOR_SECURITY_ISSUER is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MassCancelRequestType_CXLORDERSCFICODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CXLORDERSCFICODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MassCancelRequestType_CXLORDERSCFICODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CXLORDERSCFICODE));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 DerivativeSecurityListRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DerivativeSecurityListRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID is read-only.");
  return 1;
}


SWIGINTERN PyObject *DerivativeSecurityListRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DerivativeSecurityListRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID));
  return pyobj;
}


SWIGINTERN int DerivativeSecurityListRequestType_UNDELYINGSYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DerivativeSecurityListRequestType_UNDELYINGSYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *DerivativeSecurityListRequestType_UNDELYINGSYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DerivativeSecurityListRequestType_UNDELYINGSYMBOL));
  return pyobj;
}


SWIGINTERN int DerivativeSecurityListRequestType_UNDERLYING_PRODUCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DerivativeSecurityListRequestType_UNDERLYING_PRODUCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *DerivativeSecurityListRequestType_UNDERLYING_PRODUCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DerivativeSecurityListRequestType_UNDERLYING_PRODUCT));
  return pyobj;
}


SWIGINTERN int DerivativeSecurityListRequestType_UNDERLYING_SECURITYTYPE_AND_OR_CFICODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DerivativeSecurityListRequestType_UNDERLYING_SECURITYTYPE_AND_OR_CFICODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *DerivativeSecurityListRequestType_UNDERLYING_SECURITYTYPE_AND_OR_CFICODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DerivativeSecurityListRequestType_UNDERLYING_SECURITYTYPE_AND_OR_CFICODE));
  return pyobj;
}


SWIGINTERN int DerivativeSecurityListRequestType_SECURITYTYPE_AND_OR_CFICODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DerivativeSecurityListRequestType_SECURITYTYPE_AND_OR_CFICODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *DerivativeSecurityListRequestType_SECURITYTYPE_AND_OR_CFICODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DerivativeSecurityListRequestType_SECURITYTYPE_AND_OR_CFICODE));
  return pyobj;
}


SWIGINTERN int DerivativeSecurityListRequestType_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DerivativeSecurityListRequestType_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *DerivativeSecurityListRequestType_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DerivativeSecurityListRequestType_SYMBOL));
  return pyobj;
}


SWIGINTERN int DerivativeSecurityListRequestType_TRADINGSESSIONID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DerivativeSecurityListRequestType_TRADINGSESSIONID is read-only.");
  return 1;
}


SWIGINTERN PyObject *DerivativeSecurityListRequestType_TRADINGSESSIONID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DerivativeSecurityListRequestType_TRADINGSESSIONID));
  return pyobj;
}


SWIGINTERN int DerivativeSecurityListRequestType_ALL_SECURITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DerivativeSecurityListRequestType_ALL_SECURITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *DerivativeSecurityListRequestType_ALL_SECURITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DerivativeSecurityListRequestType_ALL_SECURITIES));
  return pyobj;
}


SWIGINTERN int DerivativeSecurityListRequestType_PRODUCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DerivativeSecurityListRequestType_PRODUCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *DerivativeSecurityListRequestType_PRODUCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DerivativeSecurityListRequestType_PRODUCT));
  return pyobj;
}


SWIGINTERN int CxlRejResponseTo_ORDCXLREPREQ_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejResponseTo_ORDCXLREPREQ is read-only.");
  return 1;
}


SWIGINTERN PyObject *CxlRejResponseTo_ORDCXLREPREQ_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CxlRejResponseTo_ORDCXLREPREQ));
  return pyobj;
}


SWIGINTERN int CxlRejResponseTo_ORDER_CANCEL_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejResponseTo_ORDER_CANCEL_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 CxlRejResponseTo_ORDER_CANCEL_REPLACE_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejResponseTo_ORDER_CANCEL_REPLACE_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 CxlRejResponseTo_ORDCXLREQ_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejResponseTo_ORDCXLREQ is read-only.");
  return 1;
}


SWIGINTERN PyObject *CxlRejResponseTo_ORDCXLREQ_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CxlRejResponseTo_ORDCXLREQ));
  return pyobj;
}


SWIGINTERN int QuoteCancelType_CANCEL_BY_QUOTETYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCancelType_CANCEL_BY_QUOTETYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 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 *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 QuoteCancelType_CANCEL_FOR_UNDERLYING_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCancelType_CANCEL_FOR_UNDERLYING_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 QuoteCancelType_CXLUNDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCancelType_CXLUNDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCancelType_CXLUNDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CXLUNDER));
  return pyobj;
}


SWIGINTERN int QuoteCancelType_CANCEL_ALL_QUOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCancelType_CANCEL_ALL_QUOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 QuoteCancelType_CXLSYM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCancelType_CXLSYM is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCancelType_CXLSYM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CXLSYM));
  return pyobj;
}


SWIGINTERN int QuoteCancelType_CANCEL_FOR_UNDERLYING_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCancelType_CANCEL_FOR_UNDERLYING_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 QuoteCancelType_CANCEL_FOR_SECURITY_ISSUER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCancelType_CANCEL_FOR_SECURITY_ISSUER is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 QuoteCancelType_CXLSECTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCancelType_CXLSECTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCancelType_CXLSECTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CXLSECTYPE));
  return pyobj;
}


SWIGINTERN int QuoteCancelType_CANCEL_FOR_ALL_QUOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCancelType_CANCEL_FOR_ALL_QUOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 QuoteCancelType_CXLALL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCancelType_CXLALL is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCancelType_CXLALL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CXLALL));
  return pyobj;
}


SWIGINTERN int QuoteCancelType_CANCEL_FOR_SECURITY_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCancelType_CANCEL_FOR_SECURITY_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 QuoteCancelType_CANCEL_FOR_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCancelType_CANCEL_FOR_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 StipulationType_POOLS_PER_LOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_POOLS_PER_LOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_POOLS_PER_LOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_POOLS_PER_LOT);
  return pyobj;
}


SWIGINTERN int StipulationType_MAXIMUM_LOAN_BALANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MAXIMUM_LOAN_BALANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_MAXIMUM_LOAN_BALANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MAXIMUM_LOAN_BALANCE);
  return pyobj;
}


SWIGINTERN int StipulationType_CONSTANTPREPAYMENTYIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_CONSTANTPREPAYMENTYIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_CONSTANTPREPAYMENTYIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_CONSTANTPREPAYMENTYIELD);
  return pyobj;
}


SWIGINTERN int StipulationType_CUSTOM_START_END_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_CUSTOM_START_END_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_CUSTOM_START_END_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_CUSTOM_START_END_DATE);
  return pyobj;
}


SWIGINTERN int StipulationType_CALL_PROTECTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_CALL_PROTECTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_CALL_PROTECTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_CALL_PROTECTION);
  return pyobj;
}


SWIGINTERN int StipulationType_MATURITYYEARANDMONTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MATURITYYEARANDMONTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_MATURITYYEARANDMONTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MATURITYYEARANDMONTH);
  return pyobj;
}


SWIGINTERN int StipulationType_FINALCPROFHOMEEQUITYPREPAYMENTCURVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_FINALCPROFHOMEEQUITYPREPAYMENTCURVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_FINALCPROFHOMEEQUITYPREPAYMENTCURVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_FINALCPROFHOMEEQUITYPREPAYMENTCURVE);
  return pyobj;
}


SWIGINTERN int StipulationType_MATURITYRANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MATURITYRANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_MATURITYRANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MATURITYRANGE);
  return pyobj;
}


SWIGINTERN int StipulationType_COUPON_RANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_COUPON_RANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_COUPON_RANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_COUPON_RANGE);
  return pyobj;
}


SWIGINTERN int StipulationType_PERCENTOFBMAPREPAYMENTCURVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_PERCENTOFBMAPREPAYMENTCURVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_PERCENTOFBMAPREPAYMENTCURVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_PERCENTOFBMAPREPAYMENTCURVE);
  return pyobj;
}


SWIGINTERN int StipulationType_SUBSTITUTIONSLEFTREPO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_SUBSTITUTIONSLEFTREPO is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_SUBSTITUTIONSLEFTREPO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_SUBSTITUTIONSLEFTREPO);
  return pyobj;
}


SWIGINTERN int StipulationType_LOOKBACKDAYS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_LOOKBACKDAYS is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_LOOKBACKDAYS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_LOOKBACKDAYS);
  return pyobj;
}


SWIGINTERN int StipulationType_CALLPROTECTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_CALLPROTECTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_CALLPROTECTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_CALLPROTECTION);
  return pyobj;
}


SWIGINTERN int StipulationType_MAXIMUMSUBSTITUTIONSREPO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MAXIMUMSUBSTITUTIONSREPO is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_MAXIMUMSUBSTITUTIONSREPO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MAXIMUMSUBSTITUTIONSREPO);
  return pyobj;
}


SWIGINTERN int StipulationType_YEARORYEARMONTHOFISSUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_YEARORYEARMONTHOFISSUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_YEARORYEARMONTHOFISSUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_YEARORYEARMONTHOFISSUE);
  return pyobj;
}


SWIGINTERN int StipulationType_CONSTANTPREPAYMENTRATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_CONSTANTPREPAYMENTRATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_CONSTANTPREPAYMENTRATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_CONSTANTPREPAYMENTRATE);
  return pyobj;
}


SWIGINTERN int StipulationType_ISSUE_SIZE_RANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_ISSUE_SIZE_RANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_ISSUE_SIZE_RANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_ISSUE_SIZE_RANGE);
  return pyobj;
}


SWIGINTERN int StipulationType_WEIGHTEDAVERAGEMATURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_WEIGHTEDAVERAGEMATURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_WEIGHTEDAVERAGEMATURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTEDAVERAGEMATURITY);
  return pyobj;
}


SWIGINTERN int StipulationType_CONSTANT_PREPAYMENT_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_CONSTANT_PREPAYMENT_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_CONSTANT_PREPAYMENT_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_CONSTANT_PREPAYMENT_RATE);
  return pyobj;
}


SWIGINTERN int 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 *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 StipulationType_POOLSMINIMUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_POOLSMINIMUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_POOLSMINIMUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_POOLSMINIMUM);
  return pyobj;
}


SWIGINTERN int 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 *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 StipulationType_BROKERS_SALES_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_BROKERS_SALES_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_BROKERS_SALES_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_BROKERS_SALES_CREDIT);
  return pyobj;
}


SWIGINTERN int StipulationType_ORDER_QUANTITY_INCREMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_ORDER_QUANTITY_INCREMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_ORDER_QUANTITY_INCREMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_ORDER_QUANTITY_INCREMENT);
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 StipulationType_ISSUERS_TICKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_ISSUERS_TICKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_ISSUERS_TICKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_ISSUERS_TICKER);
  return pyobj;
}


SWIGINTERN int StipulationType_ISOCURRENCYCODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_ISOCURRENCYCODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_ISOCURRENCYCODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_ISOCURRENCYCODE);
  return pyobj;
}


SWIGINTERN int 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 *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 StipulationType_DISCOUNT_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_DISCOUNT_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_DISCOUNT_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_DISCOUNT_RATE);
  return pyobj;
}


SWIGINTERN int StipulationType_VALUATIONDISCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_VALUATIONDISCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_VALUATIONDISCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_VALUATIONDISCOUNT);
  return pyobj;
}


SWIGINTERN int StipulationType_SINGLE_MONTHLY_MORTALITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_SINGLE_MONTHLY_MORTALITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_SINGLE_MONTHLY_MORTALITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_SINGLE_MONTHLY_MORTALITY);
  return pyobj;
}


SWIGINTERN int StipulationType_LOT_VARIANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_LOT_VARIANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_LOT_VARIANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_LOT_VARIANCE);
  return pyobj;
}


SWIGINTERN int StipulationType_PERCENTOFMANUFACTUREDHOUSINGPREPAYMENTCURVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_PERCENTOFMANUFACTUREDHOUSINGPREPAYMENTCURVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_PERCENTOFMANUFACTUREDHOUSINGPREPAYMENTCURVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_PERCENTOFMANUFACTUREDHOUSINGPREPAYMENTCURVE);
  return pyobj;
}


SWIGINTERN int StipulationType_FREEFORMTEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_FREEFORMTEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_FREEFORMTEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_FREEFORMTEXT);
  return pyobj;
}


SWIGINTERN int StipulationType_WHOLE_POOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_WHOLE_POOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_WHOLE_POOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_WHOLE_POOL);
  return pyobj;
}


SWIGINTERN int StipulationType_GEOGRAPHICS_AND_RANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_GEOGRAPHICS_AND_RANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_GEOGRAPHICS_AND_RANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_GEOGRAPHICS_AND_RANGE);
  return pyobj;
}


SWIGINTERN int 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 *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 StipulationType_TRADEVARIANCEVALUEINPERCENTMAXIMUMOVERORUNDERALLOCATIONALLOWED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_TRADEVARIANCEVALUEINPERCENTMAXIMUMOVERORUNDERALLOCATIONALLOWED is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_TRADEVARIANCEVALUEINPERCENTMAXIMUMOVERORUNDERALLOCATIONALLOWED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_TRADEVARIANCEVALUEINPERCENTMAXIMUMOVERORUNDERALLOCATIONALLOWED);
  return pyobj;
}


SWIGINTERN int StipulationType_FREEFORM_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_FREEFORM_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_FREEFORM_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_FREEFORM_TEXT);
  return pyobj;
}


SWIGINTERN int StipulationType_RATING_SOURCE_AND_RANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_RATING_SOURCE_AND_RANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_RATING_SOURCE_AND_RANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_RATING_SOURCE_AND_RANGE);
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 StipulationType_NUMBER_OF_PIECES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_NUMBER_OF_PIECES is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_NUMBER_OF_PIECES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_NUMBER_OF_PIECES);
  return pyobj;
}


SWIGINTERN int StipulationType_MINIMUM_INCREMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MINIMUM_INCREMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_MINIMUM_INCREMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MINIMUM_INCREMENT);
  return pyobj;
}


SWIGINTERN int StipulationType_PRODUCTIONYEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_PRODUCTIONYEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_PRODUCTIONYEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_PRODUCTIONYEAR);
  return pyobj;
}


SWIGINTERN int StipulationType_WEIGHTED_AVERAGE_MATURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_WEIGHTED_AVERAGE_MATURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_WEIGHTED_AVERAGE_MATURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTED_AVERAGE_MATURITY);
  return pyobj;
}


SWIGINTERN int StipulationType_GEOGRAPHICS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_GEOGRAPHICS is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_GEOGRAPHICS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_GEOGRAPHICS);
  return pyobj;
}


SWIGINTERN int StipulationType_MINIMUMQUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MINIMUMQUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_MINIMUMQUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MINIMUMQUANTITY);
  return pyobj;
}


SWIGINTERN int StipulationType_POOL_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_POOL_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_POOL_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_POOL_IDENTIFIER);
  return pyobj;
}


SWIGINTERN int StipulationType_MATURITY_YEAR_AND_MONTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MATURITY_YEAR_AND_MONTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_MATURITY_YEAR_AND_MONTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MATURITY_YEAR_AND_MONTH);
  return pyobj;
}


SWIGINTERN int StipulationType_PRICINGFREQUENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_PRICINGFREQUENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_PRICINGFREQUENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_PRICINGFREQUENCY);
  return pyobj;
}


SWIGINTERN int StipulationType_SECURITYTYPEINCLUDEDOREXCLUDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_SECURITYTYPEINCLUDEDOREXCLUDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_SECURITYTYPEINCLUDEDOREXCLUDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_SECURITYTYPEINCLUDEDOREXCLUDED);
  return pyobj;
}


SWIGINTERN int StipulationType_EXPLICITLOTIDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_EXPLICITLOTIDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_EXPLICITLOTIDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_EXPLICITLOTIDENTIFIER);
  return pyobj;
}


SWIGINTERN int StipulationType_MAXIMUM_SUBSTITUTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MAXIMUM_SUBSTITUTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_MAXIMUM_SUBSTITUTIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MAXIMUM_SUBSTITUTIONS);
  return pyobj;
}


SWIGINTERN int 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 *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 StipulationType_WEIGHTEDAVERAGELOANAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_WEIGHTEDAVERAGELOANAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_WEIGHTEDAVERAGELOANAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTEDAVERAGELOANAGE);
  return pyobj;
}


SWIGINTERN int StipulationType_BENCHMARK_PRICE_SOURCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_BENCHMARK_PRICE_SOURCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_BENCHMARK_PRICE_SOURCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_BENCHMARK_PRICE_SOURCE);
  return pyobj;
}


SWIGINTERN int StipulationType_MINIMUMDENOMINATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MINIMUMDENOMINATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_MINIMUMDENOMINATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MINIMUMDENOMINATION);
  return pyobj;
}


SWIGINTERN int 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 *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 StipulationType_PAYMENTFREQUENCYCALENDAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_PAYMENTFREQUENCYCALENDAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_PAYMENTFREQUENCYCALENDAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_PAYMENTFREQUENCYCALENDAR);
  return pyobj;
}


SWIGINTERN int StipulationType_POOLS_MAXIMUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_POOLS_MAXIMUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_POOLS_MAXIMUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_POOLS_MAXIMUM);
  return pyobj;
}


SWIGINTERN int StipulationType_SUBSTITUTIONS_FREQUENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_SUBSTITUTIONS_FREQUENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_SUBSTITUTIONS_FREQUENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_SUBSTITUTIONS_FREQUENCY);
  return pyobj;
}


SWIGINTERN int StipulationType_BENCHMARKPRICESOURCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_BENCHMARKPRICESOURCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_BENCHMARKPRICESOURCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_BENCHMARKPRICESOURCE);
  return pyobj;
}


SWIGINTERN int StipulationType_ABSOLUTEPREPAYMENTSPEED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_ABSOLUTEPREPAYMENTSPEED is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_ABSOLUTEPREPAYMENTSPEED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_ABSOLUTEPREPAYMENTSPEED);
  return pyobj;
}


SWIGINTERN int StipulationType_BANKQUALIFIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_BANKQUALIFIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_BANKQUALIFIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_BANKQUALIFIED);
  return pyobj;
}


SWIGINTERN int StipulationType_YIELDRANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_YIELDRANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_YIELDRANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_YIELDRANGE);
  return pyobj;
}


SWIGINTERN int StipulationType_BARGAINCONDITIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_BARGAINCONDITIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_BARGAINCONDITIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_BARGAINCONDITIONS);
  return pyobj;
}


SWIGINTERN int StipulationType_MONTHLYPREPAYMENTRATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MONTHLYPREPAYMENTRATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_MONTHLYPREPAYMENTRATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MONTHLYPREPAYMENTRATE);
  return pyobj;
}


SWIGINTERN int StipulationType_POOLSPERLOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_POOLSPERLOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_POOLSPERLOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_POOLSPERLOT);
  return pyobj;
}


SWIGINTERN int StipulationType_CONSTANT_PREPAYMENT_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_CONSTANT_PREPAYMENT_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_CONSTANT_PREPAYMENT_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_CONSTANT_PREPAYMENT_YIELD);
  return pyobj;
}


SWIGINTERN int StipulationType_MINIMUM_DENOMINATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MINIMUM_DENOMINATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_MINIMUM_DENOMINATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MINIMUM_DENOMINATION);
  return pyobj;
}


SWIGINTERN int StipulationType_ALTERNATIVE_MINIMUM_TAX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_ALTERNATIVE_MINIMUM_TAX is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_ALTERNATIVE_MINIMUM_TAX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_ALTERNATIVE_MINIMUM_TAX);
  return pyobj;
}


SWIGINTERN int StipulationType_CUSTOMSTARTENDDATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_CUSTOMSTARTENDDATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_CUSTOMSTARTENDDATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_CUSTOMSTARTENDDATE);
  return pyobj;
}


SWIGINTERN int StipulationType_TYPEOFREDEMPTIONVALUESARE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_TYPEOFREDEMPTIONVALUESARE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_TYPEOFREDEMPTIONVALUESARE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_TYPEOFREDEMPTIONVALUESARE);
  return pyobj;
}


SWIGINTERN int 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 *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 StipulationType_NUMBEROFPIECES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_NUMBEROFPIECES is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_NUMBEROFPIECES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_NUMBEROFPIECES);
  return pyobj;
}


SWIGINTERN int StipulationType_AMT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_AMT is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_AMT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_AMT);
  return pyobj;
}


SWIGINTERN int StipulationType_CONSTANTPREPAYMENTPENALTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_CONSTANTPREPAYMENTPENALTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_CONSTANTPREPAYMENTPENALTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_CONSTANTPREPAYMENTPENALTY);
  return pyobj;
}


SWIGINTERN int StipulationType_MAXIMUM_ORDER_SIZE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MAXIMUM_ORDER_SIZE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_MAXIMUM_ORDER_SIZE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MAXIMUM_ORDER_SIZE);
  return pyobj;
}


SWIGINTERN int StipulationType_AUTOREINVESTMENTATRATEORBETTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_AUTOREINVESTMENTATRATEORBETTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_AUTOREINVESTMENTATRATEORBETTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_AUTOREINVESTMENTATRATEORBETTER);
  return pyobj;
}


SWIGINTERN int StipulationType_BARGAIN_CONDITIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_BARGAIN_CONDITIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_BARGAIN_CONDITIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_BARGAIN_CONDITIONS);
  return pyobj;
}


SWIGINTERN int StipulationType_GEOGRAPHICSANDRANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_GEOGRAPHICSANDRANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_GEOGRAPHICSANDRANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_GEOGRAPHICSANDRANGE);
  return pyobj;
}


SWIGINTERN int StipulationType_LOTVARIANCEVALUEINPERCENTMAXIMUMOVERORUNDERALLOCATIONALLOWED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_LOTVARIANCEVALUEINPERCENTMAXIMUMOVERORUNDERALLOCATIONALLOWED is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_LOTVARIANCEVALUEINPERCENTMAXIMUMOVERORUNDERALLOCATIONALLOWED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_LOTVARIANCEVALUEINPERCENTMAXIMUMOVERORUNDERALLOCATIONALLOWED);
  return pyobj;
}


SWIGINTERN int StipulationType_TYPE_OF_ROLL_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_TYPE_OF_ROLL_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_TYPE_OF_ROLL_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_TYPE_OF_ROLL_TRADE);
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 StipulationType_WEIGHTED_AVERAGE_COUPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_WEIGHTED_AVERAGE_COUPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_WEIGHTED_AVERAGE_COUPON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTED_AVERAGE_COUPON);
  return pyobj;
}


SWIGINTERN int 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 *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 StipulationType_STRUCTURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_STRUCTURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_STRUCTURE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_STRUCTURE);
  return pyobj;
}


SWIGINTERN int StipulationType_WHOLEPOOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_WHOLEPOOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_WHOLEPOOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_WHOLEPOOL);
  return pyobj;
}


SWIGINTERN int StipulationType_MARKET_SECTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MARKET_SECTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_MARKET_SECTOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MARKET_SECTOR);
  return pyobj;
}


SWIGINTERN int StipulationType_MATURITY_RANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MATURITY_RANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_MATURITY_RANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MATURITY_RANGE);
  return pyobj;
}


SWIGINTERN int 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 *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 StipulationType_POOLSPERMILLION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_POOLSPERMILLION is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_POOLSPERMILLION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_POOLSPERMILLION);
  return pyobj;
}


SWIGINTERN int StipulationType_TRADE_VARIANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_TRADE_VARIANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_TRADE_VARIANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_TRADE_VARIANCE);
  return pyobj;
}


SWIGINTERN int StipulationType_ISSUERSTICKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_ISSUERSTICKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_ISSUERSTICKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_ISSUERSTICKER);
  return pyobj;
}


SWIGINTERN int StipulationType_PRICERANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_PRICERANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_PRICERANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_PRICERANGE);
  return pyobj;
}


SWIGINTERN int StipulationType_LOOKBACK_DAYS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_LOOKBACK_DAYS is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_LOOKBACK_DAYS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_LOOKBACK_DAYS);
  return pyobj;
}


SWIGINTERN int 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 *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 StipulationType_POOLS_PER_MILLION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_POOLS_PER_MILLION is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_POOLS_PER_MILLION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_POOLS_PER_MILLION);
  return pyobj;
}


SWIGINTERN int StipulationType_MINIMUMINCREMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MINIMUMINCREMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_MINIMUMINCREMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MINIMUMINCREMENT);
  return pyobj;
}


SWIGINTERN int StipulationType_MATURITY_YEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MATURITY_YEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_MATURITY_YEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MATURITY_YEAR);
  return pyobj;
}


SWIGINTERN int StipulationType_RATINGSOURCEANDRANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_RATINGSOURCEANDRANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_RATINGSOURCEANDRANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_RATINGSOURCEANDRANGE);
  return pyobj;
}


SWIGINTERN int StipulationType_AVERAGE_LOAN_SIZE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_AVERAGE_LOAN_SIZE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_AVERAGE_LOAN_SIZE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_AVERAGE_LOAN_SIZE);
  return pyobj;
}


SWIGINTERN int StipulationType_PURPOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_PURPOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_PURPOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_PURPOSE);
  return pyobj;
}


SWIGINTERN int StipulationType_ISO_CURRENCY_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_ISO_CURRENCY_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_ISO_CURRENCY_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_ISO_CURRENCY_CODE);
  return pyobj;
}


SWIGINTERN int StipulationType_RESTRICTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_RESTRICTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_RESTRICTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_RESTRICTED);
  return pyobj;
}


SWIGINTERN int StipulationType_BROKER_SALES_CREDIT_OVERRIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_BROKER_SALES_CREDIT_OVERRIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_BROKER_SALES_CREDIT_OVERRIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_BROKER_SALES_CREDIT_OVERRIDE);
  return pyobj;
}


SWIGINTERN int StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON);
  return pyobj;
}


SWIGINTERN int StipulationType_WEIGHTEDAVERAGECOUPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_WEIGHTEDAVERAGECOUPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_WEIGHTEDAVERAGECOUPON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTEDAVERAGECOUPON);
  return pyobj;
}


SWIGINTERN int StipulationType_OF_PROSPECTUS_PREPAYMENT_CURVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_OF_PROSPECTUS_PREPAYMENT_CURVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_OF_PROSPECTUS_PREPAYMENT_CURVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_OF_PROSPECTUS_PREPAYMENT_CURVE);
  return pyobj;
}


SWIGINTERN int StipulationType_ISSUESIZERANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_ISSUESIZERANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_ISSUESIZERANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_ISSUESIZERANGE);
  return pyobj;
}


SWIGINTERN int StipulationType_YEAR_OF_ISSUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_YEAR_OF_ISSUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_YEAR_OF_ISSUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_YEAR_OF_ISSUE);
  return pyobj;
}


SWIGINTERN int StipulationType_WEIGHTEDAVERAGELIFECOUPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_WEIGHTEDAVERAGELIFECOUPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_WEIGHTEDAVERAGELIFECOUPON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTEDAVERAGELIFECOUPON);
  return pyobj;
}


SWIGINTERN int StipulationType_PAYMENT_FREQUENCY_CALENDAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_PAYMENT_FREQUENCY_CALENDAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_PAYMENT_FREQUENCY_CALENDAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_PAYMENT_FREQUENCY_CALENDAR);
  return pyobj;
}


SWIGINTERN int StipulationType_TRADERS_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_TRADERS_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_TRADERS_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_TRADERS_CREDIT);
  return pyobj;
}


SWIGINTERN int StipulationType_MINIMUM_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MINIMUM_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_MINIMUM_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MINIMUM_QUANTITY);
  return pyobj;
}


SWIGINTERN int StipulationType_SUBSTITUTIONS_LEFT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_SUBSTITUTIONS_LEFT is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_SUBSTITUTIONS_LEFT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_SUBSTITUTIONS_LEFT);
  return pyobj;
}


SWIGINTERN int StipulationType_POOLS_PER_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_POOLS_PER_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_POOLS_PER_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_POOLS_PER_TRADE);
  return pyobj;
}


SWIGINTERN int StipulationType_TYPE_OF_REDEMPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_TYPE_OF_REDEMPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_TYPE_OF_REDEMPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_TYPE_OF_REDEMPTION);
  return pyobj;
}


SWIGINTERN int StipulationType_CONSTANT_PREPAYMENT_PENALTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_CONSTANT_PREPAYMENT_PENALTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_CONSTANT_PREPAYMENT_PENALTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_CONSTANT_PREPAYMENT_PENALTY);
  return pyobj;
}


SWIGINTERN int StipulationType_WEIGHTED_AVERAGE_LOAN_AGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_WEIGHTED_AVERAGE_LOAN_AGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_WEIGHTED_AVERAGE_LOAN_AGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTED_AVERAGE_LOAN_AGE);
  return pyobj;
}


SWIGINTERN int StipulationType_PRICE_RANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_PRICE_RANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_PRICE_RANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_PRICE_RANGE);
  return pyobj;
}


SWIGINTERN int StipulationType_SUBSTITUTIONSFREQUENCYREPO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_SUBSTITUTIONSFREQUENCYREPO is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_SUBSTITUTIONSFREQUENCYREPO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_SUBSTITUTIONSFREQUENCYREPO);
  return pyobj;
}


SWIGINTERN int StipulationType_PRODUCTION_YEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_PRODUCTION_YEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_PRODUCTION_YEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_PRODUCTION_YEAR);
  return pyobj;
}


SWIGINTERN int StipulationType_SINGLEMONTHLYMORTALITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_SINGLEMONTHLYMORTALITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_SINGLEMONTHLYMORTALITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_SINGLEMONTHLYMORTALITY);
  return pyobj;
}


SWIGINTERN int StipulationType_OF_BMA_PREPAYMENT_CURVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_OF_BMA_PREPAYMENT_CURVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_OF_BMA_PREPAYMENT_CURVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_OF_BMA_PREPAYMENT_CURVE);
  return pyobj;
}


SWIGINTERN int StipulationType_EXPLICIT_LOT_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_EXPLICIT_LOT_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_EXPLICIT_LOT_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_EXPLICIT_LOT_IDENTIFIER);
  return pyobj;
}


SWIGINTERN int StipulationType_ABSOLUTE_PREPAYMENT_SPEED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_ABSOLUTE_PREPAYMENT_SPEED is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_ABSOLUTE_PREPAYMENT_SPEED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_ABSOLUTE_PREPAYMENT_SPEED);
  return pyobj;
}


SWIGINTERN int StipulationType_MAXIMUMDENOMINATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MAXIMUMDENOMINATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_MAXIMUMDENOMINATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MAXIMUMDENOMINATION);
  return pyobj;
}


SWIGINTERN int StipulationType_PERCENTOFPROSPECTUSPREPAYMENTCURVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_PERCENTOFPROSPECTUSPREPAYMENTCURVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_PERCENTOFPROSPECTUSPREPAYMENTCURVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_PERCENTOFPROSPECTUSPREPAYMENTCURVE);
  return pyobj;
}


SWIGINTERN int StipulationType_VALUATION_DISCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_VALUATION_DISCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_VALUATION_DISCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_VALUATION_DISCOUNT);
  return pyobj;
}


SWIGINTERN int StipulationType_YIELD_TO_MATURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_YIELD_TO_MATURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_YIELD_TO_MATURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_YIELD_TO_MATURITY);
  return pyobj;
}


SWIGINTERN int StipulationType_WEIGHTED_AVERAGE_LIFE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_WEIGHTED_AVERAGE_LIFE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_WEIGHTED_AVERAGE_LIFE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTED_AVERAGE_LIFE);
  return pyobj;
}


SWIGINTERN int StipulationType_POOLSMAXIMUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_POOLSMAXIMUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_POOLSMAXIMUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_POOLSMAXIMUM);
  return pyobj;
}


SWIGINTERN int StipulationType_YIELD_RANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_YIELD_RANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_YIELD_RANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_YIELD_RANGE);
  return pyobj;
}


SWIGINTERN int StipulationType_PRICING_FREQUENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_PRICING_FREQUENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_PRICING_FREQUENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_PRICING_FREQUENCY);
  return pyobj;
}


SWIGINTERN int StipulationType_POOLSPERTRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_POOLSPERTRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_POOLSPERTRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_POOLSPERTRADE);
  return pyobj;
}


SWIGINTERN int StipulationType_MONTHLY_PREPAYMENT_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MONTHLY_PREPAYMENT_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_MONTHLY_PREPAYMENT_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MONTHLY_PREPAYMENT_RATE);
  return pyobj;
}


SWIGINTERN int StipulationType_COUPONRANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_COUPONRANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_COUPONRANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_COUPONRANGE);
  return pyobj;
}


SWIGINTERN int StipulationType_MARKETSECTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MARKETSECTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_MARKETSECTOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MARKETSECTOR);
  return pyobj;
}


SWIGINTERN int StipulationType_AVERAGE_FICO_SCORE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_AVERAGE_FICO_SCORE is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_AVERAGE_FICO_SCORE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_AVERAGE_FICO_SCORE);
  return pyobj;
}


SWIGINTERN int StipulationType_INSURED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_INSURED is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_INSURED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_INSURED);
  return pyobj;
}


SWIGINTERN int StipulationType_BANK_QUALIFIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_BANK_QUALIFIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *StipulationType_BANK_QUALIFIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_BANK_QUALIFIED);
  return pyobj;
}


SWIGINTERN int PriceQuoteMethod_STANDARD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceQuoteMethod_STANDARD is read-only.");
  return 1;
}


SWIGINTERN PyObject *PriceQuoteMethod_STANDARD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PriceQuoteMethod_STANDARD);
  return pyobj;
}


SWIGINTERN int PriceQuoteMethod_PERCENT_OF_PAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceQuoteMethod_PERCENT_OF_PAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *PriceQuoteMethod_PERCENT_OF_PAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PriceQuoteMethod_PERCENT_OF_PAR);
  return pyobj;
}


SWIGINTERN int PriceQuoteMethod_INDEX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceQuoteMethod_INDEX is read-only.");
  return 1;
}


SWIGINTERN PyObject *PriceQuoteMethod_INDEX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PriceQuoteMethod_INDEX);
  return pyobj;
}


SWIGINTERN int PriceQuoteMethod_INTEREST_RATE_INDEX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceQuoteMethod_INTEREST_RATE_INDEX is read-only.");
  return 1;
}


SWIGINTERN PyObject *PriceQuoteMethod_INTEREST_RATE_INDEX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PriceQuoteMethod_INTEREST_RATE_INDEX);
  return pyobj;
}


SWIGINTERN int SessionRejectReason_REQUIREDTAGMISSING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_REQUIREDTAGMISSING is read-only.");
  return 1;
}


SWIGINTERN PyObject *SessionRejectReason_REQUIREDTAGMISSING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_REQUIREDTAGMISSING));
  return pyobj;
}


SWIGINTERN int SessionRejectReason_TAGSPECIFIEDOUTOFREQUIREDORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_TAGSPECIFIEDOUTOFREQUIREDORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *SessionRejectReason_TAGSPECIFIEDOUTOFREQUIREDORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_TAGSPECIFIEDOUTOFREQUIREDORDER));
  return pyobj;
}


SWIGINTERN int 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 *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 SessionRejectReason_INVALIDTAGNUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_INVALIDTAGNUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *SessionRejectReason_INVALIDTAGNUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_INVALIDTAGNUMBER));
  return pyobj;
}


SWIGINTERN int SessionRejectReason_VALUEISINCORRECTOUTOFRANGEFORTHISTAG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_VALUEISINCORRECTOUTOFRANGEFORTHISTAG is read-only.");
  return 1;
}


SWIGINTERN PyObject *SessionRejectReason_VALUEISINCORRECTOUTOFRANGEFORTHISTAG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_VALUEISINCORRECTOUTOFRANGEFORTHISTAG));
  return pyobj;
}


SWIGINTERN int SessionRejectReason_COMPID_PROBLEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_COMPID_PROBLEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *SessionRejectReason_COMPID_PROBLEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_COMPID_PROBLEM));
  return pyobj;
}


SWIGINTERN int SessionRejectReason_SENDINGTIMEACCURACYPROBLEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_SENDINGTIMEACCURACYPROBLEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *SessionRejectReason_SENDINGTIMEACCURACYPROBLEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_SENDINGTIMEACCURACYPROBLEM));
  return pyobj;
}


SWIGINTERN int SessionRejectReason_SIGNATURE_PROBLEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_SIGNATURE_PROBLEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *SessionRejectReason_SIGNATURE_PROBLEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_SIGNATURE_PROBLEM));
  return pyobj;
}


SWIGINTERN int 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 *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 SessionRejectReason_UNDEFINEDTAG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_UNDEFINEDTAG is read-only.");
  return 1;
}


SWIGINTERN PyObject *SessionRejectReason_UNDEFINEDTAG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_UNDEFINEDTAG));
  return pyobj;
}


SWIGINTERN int SessionRejectReason_XML_VALIDATION_ERROR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_XML_VALIDATION_ERROR is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SessionRejectReason_NONDATAVALUEINCLUDESFIELDDELIMITERSOHCHARACTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_NONDATAVALUEINCLUDESFIELDDELIMITERSOHCHARACTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *SessionRejectReason_NONDATAVALUEINCLUDESFIELDDELIMITERSOHCHARACTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_NONDATAVALUEINCLUDESFIELDDELIMITERSOHCHARACTER));
  return pyobj;
}


SWIGINTERN int SessionRejectReason_UNDEFINED_TAG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_UNDEFINED_TAG is read-only.");
  return 1;
}


SWIGINTERN PyObject *SessionRejectReason_UNDEFINED_TAG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_UNDEFINED_TAG));
  return pyobj;
}


SWIGINTERN int SessionRejectReason_TAGAPPEARSMORETHANONCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_TAGAPPEARSMORETHANONCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SessionRejectReason_TAGAPPEARSMORETHANONCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_TAGAPPEARSMORETHANONCE));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 SessionRejectReason_REQUIRED_TAG_MISSING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_REQUIRED_TAG_MISSING is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SessionRejectReason_INVALIDMSGTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_INVALIDMSGTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SessionRejectReason_INVALIDMSGTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_INVALIDMSGTYPE));
  return pyobj;
}


SWIGINTERN int SessionRejectReason_XMLVALIDATIONERROR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_XMLVALIDATIONERROR is read-only.");
  return 1;
}


SWIGINTERN PyObject *SessionRejectReason_XMLVALIDATIONERROR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_XMLVALIDATIONERROR));
  return pyobj;
}


SWIGINTERN int SessionRejectReason_REPEATINGGROUPFIELDSOUTOFORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_REPEATINGGROUPFIELDSOUTOFORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *SessionRejectReason_REPEATINGGROUPFIELDSOUTOFORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_REPEATINGGROUPFIELDSOUTOFORDER));
  return pyobj;
}


SWIGINTERN int SessionRejectReason_INCORRECTNUMINGROUPCOUNTFORREPEATINGGROUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_INCORRECTNUMINGROUPCOUNTFORREPEATINGGROUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *SessionRejectReason_INCORRECTNUMINGROUPCOUNTFORREPEATINGGROUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_INCORRECTNUMINGROUPCOUNTFORREPEATINGGROUP));
  return pyobj;
}


SWIGINTERN int SessionRejectReason_TAGSPECIFIEDWITHOUTAVALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_TAGSPECIFIEDWITHOUTAVALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SessionRejectReason_TAGSPECIFIEDWITHOUTAVALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_TAGSPECIFIEDWITHOUTAVALUE));
  return pyobj;
}


SWIGINTERN int SessionRejectReason_DECRYPTIONPROBLEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_DECRYPTIONPROBLEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *SessionRejectReason_DECRYPTIONPROBLEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_DECRYPTIONPROBLEM));
  return pyobj;
}


SWIGINTERN int SessionRejectReason_INCORRECTDATAFORMATFORVALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_INCORRECTDATAFORMATFORVALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SessionRejectReason_INCORRECTDATAFORMATFORVALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_INCORRECTDATAFORMATFORVALUE));
  return pyobj;
}


SWIGINTERN int SessionRejectReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *SessionRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_OTHER));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 SessionRejectReason_COMPIDPROBLEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_COMPIDPROBLEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *SessionRejectReason_COMPIDPROBLEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_COMPIDPROBLEM));
  return pyobj;
}


SWIGINTERN int 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 *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 SessionRejectReason_SIGNATUREPROBLEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_SIGNATUREPROBLEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *SessionRejectReason_SIGNATUREPROBLEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_SIGNATUREPROBLEM));
  return pyobj;
}


SWIGINTERN int SessionRejectReason_DECRYPTION_PROBLEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_DECRYPTION_PROBLEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *SessionRejectReason_DECRYPTION_PROBLEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_DECRYPTION_PROBLEM));
  return pyobj;
}


SWIGINTERN int SessionRejectReason_INVALID_TAG_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_INVALID_TAG_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SessionRejectReason_TAGNOTDEFINEDFORTHISMESSAGETYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_TAGNOTDEFINEDFORTHISMESSAGETYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SessionRejectReason_TAGNOTDEFINEDFORTHISMESSAGETYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_TAGNOTDEFINEDFORTHISMESSAGETYPE));
  return pyobj;
}


SWIGINTERN int SessionRejectReason_VALUE_IS_INCORRECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_VALUE_IS_INCORRECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 SessionRejectReason_INVALID_MSGTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_INVALID_MSGTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SessionRejectReason_INVALID_MSGTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_INVALID_MSGTYPE));
  return pyobj;
}


SWIGINTERN int SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 DeliveryType_TRI_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryType_TRI_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeliveryType_TRI_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryType_TRI_PARTY));
  return pyobj;
}


SWIGINTERN int DeliveryType_HOLD_IN_CUSTODY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryType_HOLD_IN_CUSTODY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 DeliveryType_FREE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryType_FREE is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeliveryType_FREE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryType_FREE));
  return pyobj;
}


SWIGINTERN int DeliveryType_HOLDINCUSTODY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryType_HOLDINCUSTODY is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeliveryType_HOLDINCUSTODY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryType_HOLDINCUSTODY));
  return pyobj;
}


SWIGINTERN int DeliveryType_VERSUSPAYMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryType_VERSUSPAYMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeliveryType_VERSUSPAYMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryType_VERSUSPAYMENT));
  return pyobj;
}


SWIGINTERN int DeliveryType_VERSUS_PAYMENT_DELIVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryType_VERSUS_PAYMENT_DELIVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 DeliveryType_FREE_DELIVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryType_FREE_DELIVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeliveryType_FREE_DELIVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryType_FREE_DELIVER));
  return pyobj;
}


SWIGINTERN int DeliveryType_TRIPARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryType_TRIPARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeliveryType_TRIPARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryType_TRIPARTY));
  return pyobj;
}


SWIGINTERN int Scope_LOCAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Scope_LOCAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Scope_LOCAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Scope_LOCAL));
  return pyobj;
}


SWIGINTERN int Scope_LOCAL_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Scope_LOCAL_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Scope_LOCAL_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Scope_LOCAL_MARKET));
  return pyobj;
}


SWIGINTERN int Scope_GLOBAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Scope_GLOBAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Scope_GLOBAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Scope_GLOBAL));
  return pyobj;
}


SWIGINTERN int Scope_NATIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Scope_NATIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Scope_NATIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Scope_NATIONAL));
  return pyobj;
}


SWIGINTERN int Scope_LOCALMARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Scope_LOCALMARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Scope_LOCALMARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Scope_LOCALMARKET));
  return pyobj;
}


SWIGINTERN int DeleteReason_CANCELLATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeleteReason_CANCELLATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeleteReason_CANCELLATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DeleteReason_CANCELLATION));
  return pyobj;
}


SWIGINTERN int DeleteReason_CANCELTRADEBUST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeleteReason_CANCELTRADEBUST is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeleteReason_CANCELTRADEBUST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DeleteReason_CANCELTRADEBUST));
  return pyobj;
}


SWIGINTERN int DeleteReason_CANCELATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeleteReason_CANCELATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeleteReason_CANCELATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DeleteReason_CANCELATION));
  return pyobj;
}


SWIGINTERN int DeleteReason_ERROR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeleteReason_ERROR is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeleteReason_ERROR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DeleteReason_ERROR));
  return pyobj;
}


SWIGINTERN int InViewOfCommon_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InViewOfCommon_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *InViewOfCommon_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::InViewOfCommon_NO));
  return pyobj;
}


SWIGINTERN int InViewOfCommon_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InViewOfCommon_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *InViewOfCommon_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::InViewOfCommon_YES));
  return pyobj;
}


SWIGINTERN int NoSides_BOTHSIDES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NoSides_BOTHSIDES is read-only.");
  return 1;
}


SWIGINTERN PyObject *NoSides_BOTHSIDES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::NoSides_BOTHSIDES));
  return pyobj;
}


SWIGINTERN int NoSides_ONESIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NoSides_ONESIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *NoSides_ONESIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::NoSides_ONESIDE));
  return pyobj;
}


SWIGINTERN int NoSides_ONE_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NoSides_ONE_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *NoSides_ONE_SIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::NoSides_ONE_SIDE));
  return pyobj;
}


SWIGINTERN int NoSides_BOTH_SIDES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NoSides_BOTH_SIDES is read-only.");
  return 1;
}


SWIGINTERN PyObject *NoSides_BOTH_SIDES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::NoSides_BOTH_SIDES));
  return pyobj;
}


SWIGINTERN int SecurityType_TERM_LIQUIDITY_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TERM_LIQUIDITY_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_TERM_LIQUIDITY_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TERM_LIQUIDITY_NOTE);
  return pyobj;
}


SWIGINTERN int SecurityType_TO_BE_ANNOUNCED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TO_BE_ANNOUNCED is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_TO_BE_ANNOUNCED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TO_BE_ANNOUNCED);
  return pyobj;
}


SWIGINTERN int SecurityType_REVERSE_REPURCHASE_AGREEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_REVERSE_REPURCHASE_AGREEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_REVERSE_REPURCHASE_AGREEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_REVERSE_REPURCHASE_AGREEMENT);
  return pyobj;
}


SWIGINTERN int SecurityType_BRADY_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_BRADY_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_BRADY_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_BRADY_BOND);
  return pyobj;
}


SWIGINTERN int SecurityType_TREASURYINFLATIONPROTECTEDSECURITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TREASURYINFLATIONPROTECTEDSECURITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_TREASURYINFLATIONPROTECTEDSECURITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TREASURYINFLATIONPROTECTEDSECURITIES);
  return pyobj;
}


SWIGINTERN int SecurityType_CORP_MORTGAGE_BACKED_SECURITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CORP_MORTGAGE_BACKED_SECURITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_CORP_MORTGAGE_BACKED_SECURITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CORP_MORTGAGE_BACKED_SECURITIES);
  return pyobj;
}


SWIGINTERN int SecurityType_CERTIFICATE_OF_PARTICIPATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CERTIFICATE_OF_PARTICIPATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_CERTIFICATE_OF_PARTICIPATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CERTIFICATE_OF_PARTICIPATION);
  return pyobj;
}


SWIGINTERN int SecurityType_BUY_SELLBACK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_BUY_SELLBACK is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_BUY_SELLBACK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_BUY_SELLBACK);
  return pyobj;
}


SWIGINTERN int SecurityType_OPTIONS_ON_COMBO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_OPTIONS_ON_COMBO is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_OPTIONS_ON_COMBO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_OPTIONS_ON_COMBO);
  return pyobj;
}


SWIGINTERN int SecurityType_MULTILEG_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MULTILEG_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_MULTILEG_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MULTILEG_INSTRUMENT);
  return pyobj;
}


SWIGINTERN int SecurityType_TAX_ALLOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TAX_ALLOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_TAX_ALLOCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TAX_ALLOCATION);
  return pyobj;
}


SWIGINTERN int SecurityType_US_TREASURY_NOTE_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_US_TREASURY_NOTE_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_US_TREASURY_NOTE_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_NOTE_BOND);
  return pyobj;
}


SWIGINTERN int SecurityType_REVENUE_ANTICIPATION_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_REVENUE_ANTICIPATION_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_REVENUE_ANTICIPATION_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_REVENUE_ANTICIPATION_NOTE);
  return pyobj;
}


SWIGINTERN int SecurityType_YANKEECERTIFICATEOFDEPOSIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_YANKEECERTIFICATEOFDEPOSIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_YANKEECERTIFICATEOFDEPOSIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_YANKEECERTIFICATEOFDEPOSIT);
  return pyobj;
}


SWIGINTERN int SecurityType_MEDIUMTERMNOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MEDIUMTERMNOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_MEDIUMTERMNOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MEDIUMTERMNOTES);
  return pyobj;
}


SWIGINTERN int SecurityType_SPECIAL_TAX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SPECIAL_TAX is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_SPECIAL_TAX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SPECIAL_TAX);
  return pyobj;
}


SWIGINTERN int SecurityType_PRIVATE_EXPORT_FUNDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_PRIVATE_EXPORT_FUNDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_PRIVATE_EXPORT_FUNDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_PRIVATE_EXPORT_FUNDING);
  return pyobj;
}


SWIGINTERN int SecurityType_EUROCERTIFICATEOFDEPOSIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EUROCERTIFICATEOFDEPOSIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_EUROCERTIFICATEOFDEPOSIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EUROCERTIFICATEOFDEPOSIT);
  return pyobj;
}


SWIGINTERN int SecurityType_SPECIAL_OBLIGATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SPECIAL_OBLIGATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_SPECIAL_OBLIGATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SPECIAL_OBLIGATION);
  return pyobj;
}


SWIGINTERN int SecurityType_FX_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FX_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_FX_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FX_SWAP);
  return pyobj;
}


SWIGINTERN int SecurityType_REVOLVER_TERM_LOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_REVOLVER_TERM_LOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_REVOLVER_TERM_LOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_REVOLVER_TERM_LOAN);
  return pyobj;
}


SWIGINTERN int SecurityType_TAXEXEMPTCOMMERCIALPAPER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TAXEXEMPTCOMMERCIALPAPER is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_TAXEXEMPTCOMMERCIALPAPER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TAXEXEMPTCOMMERCIALPAPER);
  return pyobj;
}


SWIGINTERN int SecurityType_REVOLVER_LOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_REVOLVER_LOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_REVOLVER_LOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_REVOLVER_LOAN);
  return pyobj;
}


SWIGINTERN int SecurityType_CASH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CASH is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_CASH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CASH);
  return pyobj;
}


SWIGINTERN int SecurityType_USTREASURYNOTEDEPRECATEDVALUEUSETNOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_USTREASURYNOTEDEPRECATEDVALUEUSETNOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_USTREASURYNOTEDEPRECATEDVALUEUSETNOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_USTREASURYNOTEDEPRECATEDVALUEUSETNOTE);
  return pyobj;
}


SWIGINTERN int SecurityType_MISCELLANEOUS_PASS_THRU_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MISCELLANEOUS_PASS_THRU is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_MISCELLANEOUS_PASS_THRU_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MISCELLANEOUS_PASS_THRU);
  return pyobj;
}


SWIGINTERN int SecurityType_CONVERTIBLEBOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CONVERTIBLEBOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_CONVERTIBLEBOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CONVERTIBLEBOND);
  return pyobj;
}


SWIGINTERN int SecurityType_VARIABLE_RATE_DEMAND_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_VARIABLE_RATE_DEMAND_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_VARIABLE_RATE_DEMAND_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_VARIABLE_RATE_DEMAND_NOTE);
  return pyobj;
}


SWIGINTERN int SecurityType_MULTILEGINSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MULTILEGINSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_MULTILEGINSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MULTILEGINSTRUMENT);
  return pyobj;
}


SWIGINTERN int SecurityType_FEDERAL_AGENCY_DISCOUNT_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FEDERAL_AGENCY_DISCOUNT_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_FEDERAL_AGENCY_DISCOUNT_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FEDERAL_AGENCY_DISCOUNT_NOTE);
  return pyobj;
}


SWIGINTERN int SecurityType_SPECIALOBLIGATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SPECIALOBLIGATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_SPECIALOBLIGATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SPECIALOBLIGATION);
  return pyobj;
}


SWIGINTERN int SecurityType_CANADIAN_TREASURY_BILLS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CANADIAN_TREASURY_BILLS is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_CANADIAN_TREASURY_BILLS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CANADIAN_TREASURY_BILLS);
  return pyobj;
}


SWIGINTERN int SecurityType_REVENUEANTICIPATIONNOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_REVENUEANTICIPATIONNOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_REVENUEANTICIPATIONNOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_REVENUEANTICIPATIONNOTE);
  return pyobj;
}


SWIGINTERN int SecurityType_CERTIFICATEOFOBLIGATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CERTIFICATEOFOBLIGATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_CERTIFICATEOFOBLIGATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CERTIFICATEOFOBLIGATION);
  return pyobj;
}


SWIGINTERN int SecurityType_INDEXEDLINKED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_INDEXEDLINKED is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_INDEXEDLINKED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_INDEXEDLINKED);
  return pyobj;
}


SWIGINTERN int SecurityType_LETTER_OF_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_LETTER_OF_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_LETTER_OF_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_LETTER_OF_CREDIT);
  return pyobj;
}


SWIGINTERN int SecurityType_MANDATORYTENDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MANDATORYTENDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_MANDATORYTENDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MANDATORYTENDER);
  return pyobj;
}


SWIGINTERN int SecurityType_USTREASURYBOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_USTREASURYBOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_USTREASURYBOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_USTREASURYBOND);
  return pyobj;
}


SWIGINTERN int SecurityType_TERMLOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TERMLOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_TERMLOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TERMLOAN);
  return pyobj;
}


SWIGINTERN int SecurityType_OPTIONS_ON_FUTURES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_OPTIONS_ON_FUTURES is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_OPTIONS_ON_FUTURES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_OPTIONS_ON_FUTURES);
  return pyobj;
}


SWIGINTERN int SecurityType_PROMISSORYNOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_PROMISSORYNOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_PROMISSORYNOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_PROMISSORYNOTE);
  return pyobj;
}


SWIGINTERN int SecurityType_DUAL_CURRENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_DUAL_CURRENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_DUAL_CURRENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_DUAL_CURRENCY);
  return pyobj;
}


SWIGINTERN int SecurityType_WILDCARD_ENTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_WILDCARD_ENTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_WILDCARD_ENTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_WILDCARD_ENTRY);
  return pyobj;
}


SWIGINTERN int SecurityType_BANK_DEPOSITORY_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_BANK_DEPOSITORY_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_BANK_DEPOSITORY_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_BANK_DEPOSITORY_NOTE);
  return pyobj;
}


SWIGINTERN int SecurityType_REPLACED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_REPLACED is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_REPLACED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_REPLACED);
  return pyobj;
}


SWIGINTERN int SecurityType_MORTGAGE_PRINCIPAL_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MORTGAGE_PRINCIPAL_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_MORTGAGE_PRINCIPAL_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGE_PRINCIPAL_ONLY);
  return pyobj;
}


SWIGINTERN int SecurityType_CANADIAN_TREASURY_NOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CANADIAN_TREASURY_NOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_CANADIAN_TREASURY_NOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CANADIAN_TREASURY_NOTES);
  return pyobj;
}


SWIGINTERN int SecurityType_USTREASURYBILLDEPRECATEDVALUEUSETBILL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_USTREASURYBILLDEPRECATEDVALUEUSETBILL is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_USTREASURYBILLDEPRECATEDVALUEUSETBILL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_USTREASURYBILLDEPRECATEDVALUEUSETBILL);
  return pyobj;
}


SWIGINTERN int SecurityType_TOBEANNOUNCED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TOBEANNOUNCED is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_TOBEANNOUNCED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TOBEANNOUNCED);
  return pyobj;
}


SWIGINTERN int SecurityType_SECURITIES_PLEDGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SECURITIES_PLEDGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_SECURITIES_PLEDGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SECURITIES_PLEDGE);
  return pyobj;
}


SWIGINTERN int SecurityType_YANKEE_CORPORATE_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_YANKEE_CORPORATE_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_YANKEE_CORPORATE_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_YANKEE_CORPORATE_BOND);
  return pyobj;
}


SWIGINTERN int SecurityType_FX_SPOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FX_SPOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_FX_SPOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FX_SPOT);
  return pyobj;
}


SWIGINTERN int SecurityType_LIQUIDITYNOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_LIQUIDITYNOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_LIQUIDITYNOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_LIQUIDITYNOTE);
  return pyobj;
}


SWIGINTERN int SecurityType_OVERNIGHT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_OVERNIGHT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_OVERNIGHT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_OVERNIGHT);
  return pyobj;
}


SWIGINTERN int SecurityType_MORTGAGE_INTEREST_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MORTGAGE_INTEREST_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_MORTGAGE_INTEREST_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGE_INTEREST_ONLY);
  return pyobj;
}


SWIGINTERN int SecurityType_BRIDGELOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_BRIDGELOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_BRIDGELOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_BRIDGELOAN);
  return pyobj;
}


SWIGINTERN int 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 *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 SecurityType_EXTENDED_COMM_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EXTENDED_COMM_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_EXTENDED_COMM_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EXTENDED_COMM_NOTE);
  return pyobj;
}


SWIGINTERN int SecurityType_CERTIFICATEOFPARTICIPATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CERTIFICATEOFPARTICIPATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_CERTIFICATEOFPARTICIPATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CERTIFICATEOFPARTICIPATION);
  return pyobj;
}


SWIGINTERN int SecurityType_CATS_TIGERS_LIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CATS_TIGERS_LIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_CATS_TIGERS_LIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CATS_TIGERS_LIONS);
  return pyobj;
}


SWIGINTERN int SecurityType_FORWARD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FORWARD is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_FORWARD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FORWARD);
  return pyobj;
}


SWIGINTERN int SecurityType_YANKEE_CERTIFICATE_OF_DEPOSIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_YANKEE_CERTIFICATE_OF_DEPOSIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_YANKEE_CERTIFICATE_OF_DEPOSIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_YANKEE_CERTIFICATE_OF_DEPOSIT);
  return pyobj;
}


SWIGINTERN int SecurityType_PREFERRED_STOCK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_PREFERRED_STOCK is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_PREFERRED_STOCK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_PREFERRED_STOCK);
  return pyobj;
}


SWIGINTERN int SecurityType_US_TREASURY_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_US_TREASURY_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_US_TREASURY_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_BOND);
  return pyobj;
}


SWIGINTERN int SecurityType_TREASURY_INFLATION_PROTECTED_SECURITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TREASURY_INFLATION_PROTECTED_SECURITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_TREASURY_INFLATION_PROTECTED_SECURITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TREASURY_INFLATION_PROTECTED_SECURITIES);
  return pyobj;
}


SWIGINTERN int SecurityType_BUYSELLBACK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_BUYSELLBACK is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_BUYSELLBACK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_BUYSELLBACK);
  return pyobj;
}


SWIGINTERN int SecurityType_OPTIONS_ON_PHYSICAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_OPTIONS_ON_PHYSICAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_OPTIONS_ON_PHYSICAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_OPTIONS_ON_PHYSICAL);
  return pyobj;
}


SWIGINTERN int SecurityType_ASSETBACKEDSECURITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_ASSETBACKEDSECURITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_ASSETBACKEDSECURITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_ASSETBACKEDSECURITIES);
  return pyobj;
}


SWIGINTERN int SecurityType_NON_DELIVERABLE_FORWARD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_NON_DELIVERABLE_FORWARD is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_NON_DELIVERABLE_FORWARD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_NON_DELIVERABLE_FORWARD);
  return pyobj;
}


SWIGINTERN int SecurityType_MORTGAGE_PRINCIPLE_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MORTGAGE_PRINCIPLE_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_MORTGAGE_PRINCIPLE_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGE_PRINCIPLE_ONLY);
  return pyobj;
}


SWIGINTERN int SecurityType_MORTGAGE_IOETTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MORTGAGE_IOETTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_MORTGAGE_IOETTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGE_IOETTE);
  return pyobj;
}


SWIGINTERN int SecurityType_USD_SUPRANATIONAL_COUPONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_USD_SUPRANATIONAL_COUPONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_USD_SUPRANATIONAL_COUPONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_USD_SUPRANATIONAL_COUPONS);
  return pyobj;
}


SWIGINTERN int SecurityType_WARRANT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_WARRANT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_WARRANT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_WARRANT);
  return pyobj;
}


SWIGINTERN int SecurityType_FOREIGN_EXCHANGE_CONTRACT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FOREIGN_EXCHANGE_CONTRACT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_FOREIGN_EXCHANGE_CONTRACT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FOREIGN_EXCHANGE_CONTRACT);
  return pyobj;
}


SWIGINTERN int SecurityType_FOREIGNEXCHANGECONTRACT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FOREIGNEXCHANGECONTRACT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_FOREIGNEXCHANGECONTRACT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FOREIGNEXCHANGECONTRACT);
  return pyobj;
}


SWIGINTERN int 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 *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 SecurityType_SPECIAL_ASSESSMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SPECIAL_ASSESSMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_SPECIAL_ASSESSMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SPECIAL_ASSESSMENT);
  return pyobj;
}


SWIGINTERN int SecurityType_EUROSUPRANATIONALCOUPONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EUROSUPRANATIONALCOUPONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_EUROSUPRANATIONALCOUPONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EUROSUPRANATIONALCOUPONS);
  return pyobj;
}


SWIGINTERN int SecurityType_DEBTOR_IN_POSSESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_DEBTOR_IN_POSSESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_DEBTOR_IN_POSSESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_DEBTOR_IN_POSSESSION);
  return pyobj;
}


SWIGINTERN int SecurityType_CANADIAN_MONEY_MARKETS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CANADIAN_MONEY_MARKETS is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_CANADIAN_MONEY_MARKETS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CANADIAN_MONEY_MARKETS);
  return pyobj;
}


SWIGINTERN int SecurityType_MORTGAGEPRINCIPALONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MORTGAGEPRINCIPALONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_MORTGAGEPRINCIPALONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGEPRINCIPALONLY);
  return pyobj;
}


SWIGINTERN int SecurityType_USTREASURYNOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_USTREASURYNOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_USTREASURYNOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_USTREASURYNOTE);
  return pyobj;
}


SWIGINTERN int SecurityType_DEBTORINPOSSESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_DEBTORINPOSSESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_DEBTORINPOSSESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_DEBTORINPOSSESSION);
  return pyobj;
}


SWIGINTERN int SecurityType_REVENUEBONDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_REVENUEBONDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_REVENUEBONDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_REVENUEBONDS);
  return pyobj;
}


SWIGINTERN int SecurityType_MORTGAGEINTERESTONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MORTGAGEINTERESTONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_MORTGAGEINTERESTONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGEINTERESTONLY);
  return pyobj;
}


SWIGINTERN int SecurityType_DEPOSITNOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_DEPOSITNOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_DEPOSITNOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_DEPOSITNOTES);
  return pyobj;
}


SWIGINTERN int 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 *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 SecurityType_MORTGAGEPRIVATEPLACEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MORTGAGEPRIVATEPLACEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_MORTGAGEPRIVATEPLACEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGEPRIVATEPLACEMENT);
  return pyobj;
}


SWIGINTERN int SecurityType_NO_SECURITY_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_NO_SECURITY_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_NO_SECURITY_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_NO_SECURITY_TYPE);
  return pyobj;
}


SWIGINTERN int SecurityType_SPECIALASSESSMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SPECIALASSESSMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_SPECIALASSESSMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SPECIALASSESSMENT);
  return pyobj;
}


SWIGINTERN int SecurityType_LETTEROFCREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_LETTEROFCREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_LETTEROFCREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_LETTEROFCREDIT);
  return pyobj;
}


SWIGINTERN int SecurityType_TAXALLOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TAXALLOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_TAXALLOCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TAXALLOCATION);
  return pyobj;
}


SWIGINTERN int SecurityType_TAXABLE_MUNICIPAL_CP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TAXABLE_MUNICIPAL_CP is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_TAXABLE_MUNICIPAL_CP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TAXABLE_MUNICIPAL_CP);
  return pyobj;
}


SWIGINTERN int SecurityType_OPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_OPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_OPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_OPTION);
  return pyobj;
}


SWIGINTERN int SecurityType_NOSECURITYTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_NOSECURITYTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_NOSECURITYTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_NOSECURITYTYPE);
  return pyobj;
}


SWIGINTERN int SecurityType_PROMISSORY_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_PROMISSORY_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_PROMISSORY_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_PROMISSORY_NOTE);
  return pyobj;
}


SWIGINTERN int SecurityType_COLLATERALIZEDMORTGAGEOBLIGATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_COLLATERALIZEDMORTGAGEOBLIGATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_COLLATERALIZEDMORTGAGEOBLIGATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_COLLATERALIZEDMORTGAGEOBLIGATION);
  return pyobj;
}


SWIGINTERN int SecurityType_DUALCURRENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_DUALCURRENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_DUALCURRENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_DUALCURRENCY);
  return pyobj;
}


SWIGINTERN int SecurityType_CREDIT_DEFAULT_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CREDIT_DEFAULT_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_CREDIT_DEFAULT_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CREDIT_DEFAULT_SWAP);
  return pyobj;
}


SWIGINTERN int SecurityType_TAXANTICIPATIONNOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TAXANTICIPATIONNOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_TAXANTICIPATIONNOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TAXANTICIPATIONNOTE);
  return pyobj;
}


SWIGINTERN int SecurityType_MORTGAGE_PRIVATE_PLACEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MORTGAGE_PRIVATE_PLACEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_MORTGAGE_PRIVATE_PLACEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGE_PRIVATE_PLACEMENT);
  return pyobj;
}


SWIGINTERN int SecurityType_GENERAL_OBLIGATION_BONDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_GENERAL_OBLIGATION_BONDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_GENERAL_OBLIGATION_BONDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_GENERAL_OBLIGATION_BONDS);
  return pyobj;
}


SWIGINTERN int SecurityType_SHORTTERMLOANNOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SHORTTERMLOANNOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_SHORTTERMLOANNOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SHORTTERMLOANNOTE);
  return pyobj;
}


SWIGINTERN int SecurityType_COMMERCIAL_PAPER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_COMMERCIAL_PAPER is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_COMMERCIAL_PAPER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_COMMERCIAL_PAPER);
  return pyobj;
}


SWIGINTERN int SecurityType_MORTGAGE_BACKED_SECURITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MORTGAGE_BACKED_SECURITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_MORTGAGE_BACKED_SECURITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGE_BACKED_SECURITIES);
  return pyobj;
}


SWIGINTERN int SecurityType_EURO_SOVEREIGNS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EURO_SOVEREIGNS is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_EURO_SOVEREIGNS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EURO_SOVEREIGNS);
  return pyobj;
}


SWIGINTERN int SecurityType_TAX_REVENUE_ANTICIPATION_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TAX_REVENUE_ANTICIPATION_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_TAX_REVENUE_ANTICIPATION_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TAX_REVENUE_ANTICIPATION_NOTE);
  return pyobj;
}


SWIGINTERN int SecurityType_PFANDBRIEFE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_PFANDBRIEFE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_PFANDBRIEFE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_PFANDBRIEFE);
  return pyobj;
}


SWIGINTERN int SecurityType_OTHER_ANTICIPATION_NOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_OTHER_ANTICIPATION_NOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_OTHER_ANTICIPATION_NOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_OTHER_ANTICIPATION_NOTES);
  return pyobj;
}


SWIGINTERN int SecurityType_TAX_EXEMPT_COMMERCIAL_PAPER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TAX_EXEMPT_COMMERCIAL_PAPER is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_TAX_EXEMPT_COMMERCIAL_PAPER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TAX_EXEMPT_COMMERCIAL_PAPER);
  return pyobj;
}


SWIGINTERN int SecurityType_PRIVATEEXPORTFUNDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_PRIVATEEXPORTFUNDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_PRIVATEEXPORTFUNDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_PRIVATEEXPORTFUNDING);
  return pyobj;
}


SWIGINTERN int SecurityType_OTHERANTICIPATIONNOTESBANGANETC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_OTHERANTICIPATIONNOTESBANGANETC is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_OTHERANTICIPATIONNOTESBANGANETC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_OTHERANTICIPATIONNOTESBANGANETC);
  return pyobj;
}


SWIGINTERN int SecurityType_TAX_ANTICIPATION_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TAX_ANTICIPATION_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_TAX_ANTICIPATION_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TAX_ANTICIPATION_NOTE);
  return pyobj;
}


SWIGINTERN int SecurityType_TREASURY_BILL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TREASURY_BILL is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_TREASURY_BILL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TREASURY_BILL);
  return pyobj;
}


SWIGINTERN int SecurityType_PLAZOS_FIJOS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_PLAZOS_FIJOS is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_PLAZOS_FIJOS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_PLAZOS_FIJOS);
  return pyobj;
}


SWIGINTERN int SecurityType_EURO_COMMERCIAL_PAPER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EURO_COMMERCIAL_PAPER is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_EURO_COMMERCIAL_PAPER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EURO_COMMERCIAL_PAPER);
  return pyobj;
}


SWIGINTERN int SecurityType_MANDATORY_TENDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MANDATORY_TENDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_MANDATORY_TENDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MANDATORY_TENDER);
  return pyobj;
}


SWIGINTERN int SecurityType_COLLATERALIZED_MORTGAGE_OBLIGATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_COLLATERALIZED_MORTGAGE_OBLIGATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_COLLATERALIZED_MORTGAGE_OBLIGATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_COLLATERALIZED_MORTGAGE_OBLIGATION);
  return pyobj;
}


SWIGINTERN int SecurityType_PREFERREDSTOCK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_PREFERREDSTOCK is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_PREFERREDSTOCK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_PREFERREDSTOCK);
  return pyobj;
}


SWIGINTERN int SecurityType_VARIABLERATEDEMANDNOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_VARIABLERATEDEMANDNOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_VARIABLERATEDEMANDNOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_VARIABLERATEDEMANDNOTE);
  return pyobj;
}


SWIGINTERN int SecurityType_DEFAULTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_DEFAULTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_DEFAULTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_DEFAULTED);
  return pyobj;
}


SWIGINTERN int SecurityType_INDEXED_LINKED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_INDEXED_LINKED is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_INDEXED_LINKED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_INDEXED_LINKED);
  return pyobj;
}


SWIGINTERN int SecurityType_IOETTE_MORTGAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_IOETTE_MORTGAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_IOETTE_MORTGAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_IOETTE_MORTGAGE);
  return pyobj;
}


SWIGINTERN int SecurityType_CERTIFICATE_OF_DEPOSIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CERTIFICATE_OF_DEPOSIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_CERTIFICATE_OF_DEPOSIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CERTIFICATE_OF_DEPOSIT);
  return pyobj;
}


SWIGINTERN int SecurityType_BILLOFEXCHANGES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_BILLOFEXCHANGES is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_BILLOFEXCHANGES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_BILLOFEXCHANGES);
  return pyobj;
}


SWIGINTERN int SecurityType_PRINCIPALSTRIPOFACALLABLEBONDORNOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_PRINCIPALSTRIPOFACALLABLEBONDORNOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_PRINCIPALSTRIPOFACALLABLEBONDORNOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_PRINCIPALSTRIPOFACALLABLEBONDORNOTE);
  return pyobj;
}


SWIGINTERN int SecurityType_EUROSOVEREIGNS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EUROSOVEREIGNS is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_EUROSOVEREIGNS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EUROSOVEREIGNS);
  return pyobj;
}


SWIGINTERN int SecurityType_TIME_DEPOSIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TIME_DEPOSIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_TIME_DEPOSIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TIME_DEPOSIT);
  return pyobj;
}


SWIGINTERN int SecurityType_CORPORATEBOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CORPORATEBOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_CORPORATEBOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CORPORATEBOND);
  return pyobj;
}


SWIGINTERN int SecurityType_FX_FORWARD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FX_FORWARD is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_FX_FORWARD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FX_FORWARD);
  return pyobj;
}


SWIGINTERN int 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 *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 SecurityType_US_TREASURY_NOTE_TNOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_US_TREASURY_NOTE_TNOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_US_TREASURY_NOTE_TNOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_NOTE_TNOTE);
  return pyobj;
}


SWIGINTERN int SecurityType_MORTGAGEBACKEDSECURITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MORTGAGEBACKEDSECURITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_MORTGAGEBACKEDSECURITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGEBACKEDSECURITIES);
  return pyobj;
}


SWIGINTERN int SecurityType_DEPOSIT_NOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_DEPOSIT_NOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_DEPOSIT_NOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_DEPOSIT_NOTES);
  return pyobj;
}


SWIGINTERN int SecurityType_CORPORATEPRIVATEPLACEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CORPORATEPRIVATEPLACEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_CORPORATEPRIVATEPLACEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CORPORATEPRIVATEPLACEMENT);
  return pyobj;
}


SWIGINTERN int SecurityType_FEDERAL_HOUSING_AUTHORITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FEDERAL_HOUSING_AUTHORITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_FEDERAL_HOUSING_AUTHORITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FEDERAL_HOUSING_AUTHORITY);
  return pyobj;
}


SWIGINTERN int SecurityType_MATURED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MATURED is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_MATURED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MATURED);
  return pyobj;
}


SWIGINTERN int SecurityType_SWINGLINEFACILITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SWINGLINEFACILITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_SWINGLINEFACILITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SWINGLINEFACILITY);
  return pyobj;
}


SWIGINTERN int SecurityType_MULTI_LEG_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MULTI_LEG_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_MULTI_LEG_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MULTI_LEG_INSTRUMENT);
  return pyobj;
}


SWIGINTERN int SecurityType_CANADIAN_PROVINCIAL_BONDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CANADIAN_PROVINCIAL_BONDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_CANADIAN_PROVINCIAL_BONDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CANADIAN_PROVINCIAL_BONDS);
  return pyobj;
}


SWIGINTERN int SecurityType_MEDIUM_TERM_NOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MEDIUM_TERM_NOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_MEDIUM_TERM_NOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MEDIUM_TERM_NOTES);
  return pyobj;
}


SWIGINTERN int SecurityType_RETIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_RETIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_RETIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_RETIRED);
  return pyobj;
}


SWIGINTERN int SecurityType_MUTUAL_FUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MUTUAL_FUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_MUTUAL_FUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MUTUAL_FUND);
  return pyobj;
}


SWIGINTERN int SecurityType_SECURITIESPLEDGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SECURITIESPLEDGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_SECURITIESPLEDGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SECURITIESPLEDGE);
  return pyobj;
}


SWIGINTERN int SecurityType_COMMERCIALPAPER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_COMMERCIALPAPER is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_COMMERCIALPAPER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_COMMERCIALPAPER);
  return pyobj;
}


SWIGINTERN int SecurityType_REPURCHASE_AGREEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_REPURCHASE_AGREEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_REPURCHASE_AGREEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_REPURCHASE_AGREEMENT);
  return pyobj;
}


SWIGINTERN int SecurityType_BILL_OF_EXCHANGES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_BILL_OF_EXCHANGES is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_BILL_OF_EXCHANGES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_BILL_OF_EXCHANGES);
  return pyobj;
}


SWIGINTERN int SecurityType_MUTUALFUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MUTUALFUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_MUTUALFUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MUTUALFUND);
  return pyobj;
}


SWIGINTERN int SecurityType_COLLATERALIZE_MORTGAGE_OBLIGATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_COLLATERALIZE_MORTGAGE_OBLIGATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_COLLATERALIZE_MORTGAGE_OBLIGATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_COLLATERALIZE_MORTGAGE_OBLIGATION);
  return pyobj;
}


SWIGINTERN int SecurityType_EXTENDEDCOMMNOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EXTENDEDCOMMNOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_EXTENDEDCOMMNOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EXTENDEDCOMMNOTE);
  return pyobj;
}


SWIGINTERN int SecurityType_FEDERAL_HOME_LOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FEDERAL_HOME_LOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_FEDERAL_HOME_LOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FEDERAL_HOME_LOAN);
  return pyobj;
}


SWIGINTERN int SecurityType_REVOLVERLOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_REVOLVERLOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_REVOLVERLOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_REVOLVERLOAN);
  return pyobj;
}


SWIGINTERN int 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 *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 SecurityType_STRUCTURED_NOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_STRUCTURED_NOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_STRUCTURED_NOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_STRUCTURED_NOTES);
  return pyobj;
}


SWIGINTERN int SecurityType_INTERESTSTRIPFROMANYBONDORNOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_INTERESTSTRIPFROMANYBONDORNOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_INTERESTSTRIPFROMANYBONDORNOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_INTERESTSTRIPFROMANYBONDORNOTE);
  return pyobj;
}


SWIGINTERN int SecurityType_CANADIAN_MORTGAGE_BONDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CANADIAN_MORTGAGE_BONDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_CANADIAN_MORTGAGE_BONDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CANADIAN_MORTGAGE_BONDS);
  return pyobj;
}


SWIGINTERN int SecurityType_REPURCHASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_REPURCHASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_REPURCHASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_REPURCHASE);
  return pyobj;
}


SWIGINTERN int SecurityType_AGENCY_POOLS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_AGENCY_POOLS is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_AGENCY_POOLS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_AGENCY_POOLS);
  return pyobj;
}


SWIGINTERN int SecurityType_EURO_CORPORATE_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EURO_CORPORATE_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_EURO_CORPORATE_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EURO_CORPORATE_BOND);
  return pyobj;
}


SWIGINTERN int SecurityType_SWING_LINE_FACILITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SWING_LINE_FACILITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_SWING_LINE_FACILITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SWING_LINE_FACILITY);
  return pyobj;
}


SWIGINTERN int SecurityType_USDSUPRANATIONALCOUPONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_USDSUPRANATIONALCOUPONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_USDSUPRANATIONALCOUPONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_USDSUPRANATIONALCOUPONS);
  return pyobj;
}


SWIGINTERN int SecurityType_REVOLVERTERMLOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_REVOLVERTERMLOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_REVOLVERTERMLOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_REVOLVERTERMLOAN);
  return pyobj;
}


SWIGINTERN int SecurityType_LIQUIDITY_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_LIQUIDITY_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_LIQUIDITY_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_LIQUIDITY_NOTE);
  return pyobj;
}


SWIGINTERN int SecurityType_MISCELLANEOUSPASSTHROUGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MISCELLANEOUSPASSTHROUGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_MISCELLANEOUSPASSTHROUGH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MISCELLANEOUSPASSTHROUGH);
  return pyobj;
}


SWIGINTERN int SecurityType_CONVERTIBLE_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CONVERTIBLE_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_CONVERTIBLE_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CONVERTIBLE_BOND);
  return pyobj;
}


SWIGINTERN int SecurityType_ASSET_BACKED_SECURITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_ASSET_BACKED_SECURITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_ASSET_BACKED_SECURITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_ASSET_BACKED_SECURITIES);
  return pyobj;
}


SWIGINTERN int SecurityType_WILDCARDENTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_WILDCARDENTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_WILDCARDENTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_WILDCARDENTRY);
  return pyobj;
}


SWIGINTERN int SecurityType_YANKEECORPORATEBOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_YANKEECORPORATEBOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_YANKEECORPORATEBOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_YANKEECORPORATEBOND);
  return pyobj;
}


SWIGINTERN int SecurityType_TAXREVENUEANTICIPATIONNOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TAXREVENUEANTICIPATIONNOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_TAXREVENUEANTICIPATIONNOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TAXREVENUEANTICIPATIONNOTE);
  return pyobj;
}


SWIGINTERN int SecurityType_GOVERNMENT_NATIONAL_MORTGAGE_ASSOCIATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_GOVERNMENT_NATIONAL_MORTGAGE_ASSOCIATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_GOVERNMENT_NATIONAL_MORTGAGE_ASSOCIATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_GOVERNMENT_NATIONAL_MORTGAGE_ASSOCIATION);
  return pyobj;
}


SWIGINTERN int SecurityType_BRADYBOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_BRADYBOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_BRADYBOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_BRADYBOND);
  return pyobj;
}


SWIGINTERN int SecurityType_USTREASURYBILL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_USTREASURYBILL is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_USTREASURYBILL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_USTREASURYBILL);
  return pyobj;
}


SWIGINTERN int SecurityType_STUDENT_LOAN_MARKETING_ASSOCIATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_STUDENT_LOAN_MARKETING_ASSOCIATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_STUDENT_LOAN_MARKETING_ASSOCIATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_STUDENT_LOAN_MARKETING_ASSOCIATION);
  return pyobj;
}


SWIGINTERN int SecurityType_EUROCORPORATEBOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EUROCORPORATEBOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_EUROCORPORATEBOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EUROCORPORATEBOND);
  return pyobj;
}


SWIGINTERN int SecurityType_FUTURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FUTURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_FUTURE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FUTURE);
  return pyobj;
}


SWIGINTERN int SecurityType_US_TREASURY_BILL_TBILL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_US_TREASURY_BILL_TBILL is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_US_TREASURY_BILL_TBILL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_BILL_TBILL);
  return pyobj;
}


SWIGINTERN int SecurityType_TREASURIES_PLUS_AGENCY_DEBENTURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TREASURIES_PLUS_AGENCY_DEBENTURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_TREASURIES_PLUS_AGENCY_DEBENTURE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TREASURIES_PLUS_AGENCY_DEBENTURE);
  return pyobj;
}


SWIGINTERN int SecurityType_EURO_CERTIFICATE_OF_DEPOSIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EURO_CERTIFICATE_OF_DEPOSIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_EURO_CERTIFICATE_OF_DEPOSIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EURO_CERTIFICATE_OF_DEPOSIT);
  return pyobj;
}


SWIGINTERN int SecurityType_BANKERS_ACCEPTANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_BANKERS_ACCEPTANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_BANKERS_ACCEPTANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_BANKERS_ACCEPTANCE);
  return pyobj;
}


SWIGINTERN int SecurityType_AMENDEDRESTATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_AMENDEDRESTATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_AMENDEDRESTATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_AMENDEDRESTATED);
  return pyobj;
}


SWIGINTERN int SecurityType_TERM_LOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TERM_LOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_TERM_LOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TERM_LOAN);
  return pyobj;
}


SWIGINTERN int SecurityType_BANKNOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_BANKNOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_BANKNOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_BANKNOTES);
  return pyobj;
}


SWIGINTERN int SecurityType_SHORT_TERM_LOAN_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SHORT_TERM_LOAN_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_SHORT_TERM_LOAN_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SHORT_TERM_LOAN_NOTE);
  return pyobj;
}


SWIGINTERN int SecurityType_AMENDED_RESTATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_AMENDED_RESTATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_AMENDED_RESTATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_AMENDED_RESTATED);
  return pyobj;
}


SWIGINTERN int SecurityType_INTEREST_RATE_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_INTEREST_RATE_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_INTEREST_RATE_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_INTEREST_RATE_SWAP);
  return pyobj;
}


SWIGINTERN int SecurityType_EUROCOMMERCIALPAPER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EUROCOMMERCIALPAPER is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_EUROCOMMERCIALPAPER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EUROCOMMERCIALPAPER);
  return pyobj;
}


SWIGINTERN int SecurityType_US_TREASURY_NOTE_UST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_US_TREASURY_NOTE_UST is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_US_TREASURY_NOTE_UST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_NOTE_UST);
  return pyobj;
}


SWIGINTERN int SecurityType_US_TREASURY_BILL_USTB_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_US_TREASURY_BILL_USTB is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_US_TREASURY_BILL_USTB_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_BILL_USTB);
  return pyobj;
}


SWIGINTERN int SecurityType_FEDERAL_NATIONAL_MORTGAGE_ASSOCIATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FEDERAL_NATIONAL_MORTGAGE_ASSOCIATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_FEDERAL_NATIONAL_MORTGAGE_ASSOCIATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FEDERAL_NATIONAL_MORTGAGE_ASSOCIATION);
  return pyobj;
}


SWIGINTERN int SecurityType_WITHDRAWN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_WITHDRAWN is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_WITHDRAWN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_WITHDRAWN);
  return pyobj;
}


SWIGINTERN int SecurityType_CORPORATE_PRIVATE_PLACEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CORPORATE_PRIVATE_PLACEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_CORPORATE_PRIVATE_PLACEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CORPORATE_PRIVATE_PLACEMENT);
  return pyobj;
}


SWIGINTERN int SecurityType_CERTIFICATE_OF_OBLIGATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CERTIFICATE_OF_OBLIGATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_CERTIFICATE_OF_OBLIGATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CERTIFICATE_OF_OBLIGATION);
  return pyobj;
}


SWIGINTERN int 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 *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 SecurityType_STRUCTUREDNOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_STRUCTUREDNOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_STRUCTUREDNOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_STRUCTUREDNOTES);
  return pyobj;
}


SWIGINTERN int SecurityType_BANKERSACCEPTANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_BANKERSACCEPTANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_BANKERSACCEPTANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_BANKERSACCEPTANCE);
  return pyobj;
}


SWIGINTERN int SecurityType_NO_ISITC_SECURITY_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_NO_ISITC_SECURITY_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_NO_ISITC_SECURITY_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_NO_ISITC_SECURITY_TYPE);
  return pyobj;
}


SWIGINTERN int SecurityType_CALLLOANS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CALLLOANS is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_CALLLOANS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CALLLOANS);
  return pyobj;
}


SWIGINTERN int SecurityType_MISCELLANEOUS_PASS_THROUGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MISCELLANEOUS_PASS_THROUGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_MISCELLANEOUS_PASS_THROUGH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MISCELLANEOUS_PASS_THROUGH);
  return pyobj;
}


SWIGINTERN int SecurityType_FEDERAL_AGENCY_COUPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FEDERAL_AGENCY_COUPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_FEDERAL_AGENCY_COUPON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FEDERAL_AGENCY_COUPON);
  return pyobj;
}


SWIGINTERN int SecurityType_CORPORATE_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CORPORATE_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_CORPORATE_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CORPORATE_BOND);
  return pyobj;
}


SWIGINTERN int 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 *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 SecurityType_CORPMORTGAGEBACKEDSECURITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CORPMORTGAGEBACKEDSECURITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_CORPMORTGAGEBACKEDSECURITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CORPMORTGAGEBACKEDSECURITIES);
  return pyobj;
}


SWIGINTERN int SecurityType_EURO_SUPRANATIONAL_COUPONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EURO_SUPRANATIONAL_COUPONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_EURO_SUPRANATIONAL_COUPONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EURO_SUPRANATIONAL_COUPONS);
  return pyobj;
}


SWIGINTERN int SecurityType_CALL_LOANS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CALL_LOANS is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_CALL_LOANS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CALL_LOANS);
  return pyobj;
}


SWIGINTERN int SecurityType_CERTIFICATEOFDEPOSIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CERTIFICATEOFDEPOSIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_CERTIFICATEOFDEPOSIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CERTIFICATEOFDEPOSIT);
  return pyobj;
}


SWIGINTERN int SecurityType_SECURED_LIQUIDITY_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SECURED_LIQUIDITY_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_SECURED_LIQUIDITY_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SECURED_LIQUIDITY_NOTE);
  return pyobj;
}


SWIGINTERN int SecurityType_TIMEDEPOSIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TIMEDEPOSIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_TIMEDEPOSIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TIMEDEPOSIT);
  return pyobj;
}


SWIGINTERN int SecurityType_BANK_NOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_BANK_NOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_BANK_NOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_BANK_NOTES);
  return pyobj;
}


SWIGINTERN int SecurityType_US_TREASURY_BILL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_US_TREASURY_BILL is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_US_TREASURY_BILL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_BILL);
  return pyobj;
}


SWIGINTERN int SecurityType_GENERALOBLIGATIONBONDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_GENERALOBLIGATIONBONDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_GENERALOBLIGATIONBONDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_GENERALOBLIGATIONBONDS);
  return pyobj;
}


SWIGINTERN int SecurityType_COMMONSTOCK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_COMMONSTOCK is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_COMMONSTOCK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_COMMONSTOCK);
  return pyobj;
}


SWIGINTERN int SecurityType_PLAZOSFIJOS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_PLAZOSFIJOS is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_PLAZOSFIJOS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_PLAZOSFIJOS);
  return pyobj;
}


SWIGINTERN int SecurityType_SECURITIES_LOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SECURITIES_LOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_SECURITIES_LOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SECURITIES_LOAN);
  return pyobj;
}


SWIGINTERN int SecurityType_SECURITIESLOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SECURITIESLOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_SECURITIESLOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SECURITIESLOAN);
  return pyobj;
}


SWIGINTERN int SecurityType_MUNICIPAL_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MUNICIPAL_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_MUNICIPAL_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MUNICIPAL_BOND);
  return pyobj;
}


SWIGINTERN int SecurityType_REVENUE_BONDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_REVENUE_BONDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_REVENUE_BONDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_REVENUE_BONDS);
  return pyobj;
}


SWIGINTERN int SecurityType_SPECIALTAX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SPECIALTAX is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_SPECIALTAX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SPECIALTAX);
  return pyobj;
}


SWIGINTERN int SecurityType_PRINCIPALSTRIPFROMANONCALLABLEBONDORNOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_PRINCIPALSTRIPFROMANONCALLABLEBONDORNOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_PRINCIPALSTRIPFROMANONCALLABLEBONDORNOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_PRINCIPALSTRIPFROMANONCALLABLEBONDORNOTE);
  return pyobj;
}


SWIGINTERN int SecurityType_BRIDGE_LOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_BRIDGE_LOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_BRIDGE_LOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_BRIDGE_LOAN);
  return pyobj;
}


SWIGINTERN int SecurityType_IOETTEMORTGAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_IOETTEMORTGAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_IOETTEMORTGAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_IOETTEMORTGAGE);
  return pyobj;
}


SWIGINTERN int SecurityType_FEDERALAGENCYCOUPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FEDERALAGENCYCOUPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_FEDERALAGENCYCOUPON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FEDERALAGENCYCOUPON);
  return pyobj;
}


SWIGINTERN int SecurityType_COMMON_STOCK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_COMMON_STOCK is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_COMMON_STOCK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_COMMON_STOCK);
  return pyobj;
}


SWIGINTERN int SecurityType_FEDERALAGENCYDISCOUNTNOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FEDERALAGENCYDISCOUNTNOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityType_FEDERALAGENCYDISCOUNTNOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FEDERALAGENCYDISCOUNTNOTE);
  return pyobj;
}


SWIGINTERN int RoundingDirection_ROUNDUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RoundingDirection_ROUNDUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *RoundingDirection_ROUNDUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RoundingDirection_ROUNDUP));
  return pyobj;
}


SWIGINTERN int RoundingDirection_ROUND_DOWN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RoundingDirection_ROUND_DOWN is read-only.");
  return 1;
}


SWIGINTERN PyObject *RoundingDirection_ROUND_DOWN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RoundingDirection_ROUND_DOWN));
  return pyobj;
}


SWIGINTERN int RoundingDirection_ROUND_TO_NEAREST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RoundingDirection_ROUND_TO_NEAREST is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 RoundingDirection_ROUND_UP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RoundingDirection_ROUND_UP is read-only.");
  return 1;
}


SWIGINTERN PyObject *RoundingDirection_ROUND_UP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RoundingDirection_ROUND_UP));
  return pyobj;
}


SWIGINTERN int RoundingDirection_ROUNDDOWN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RoundingDirection_ROUNDDOWN is read-only.");
  return 1;
}


SWIGINTERN PyObject *RoundingDirection_ROUNDDOWN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RoundingDirection_ROUNDDOWN));
  return pyobj;
}


SWIGINTERN int RoundingDirection_ROUNDNEAREST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RoundingDirection_ROUNDNEAREST is read-only.");
  return 1;
}


SWIGINTERN PyObject *RoundingDirection_ROUNDNEAREST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RoundingDirection_ROUNDNEAREST));
  return pyobj;
}


SWIGINTERN int TimeUnit_MINUTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeUnit_MINUTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TimeUnit_MINUTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TimeUnit_MINUTE);
  return pyobj;
}


SWIGINTERN int TimeUnit_WEEK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeUnit_WEEK is read-only.");
  return 1;
}


SWIGINTERN PyObject *TimeUnit_WEEK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TimeUnit_WEEK);
  return pyobj;
}


SWIGINTERN int TimeUnit_SECOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeUnit_SECOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *TimeUnit_SECOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TimeUnit_SECOND);
  return pyobj;
}


SWIGINTERN int TimeUnit_MONTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeUnit_MONTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *TimeUnit_MONTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TimeUnit_MONTH);
  return pyobj;
}


SWIGINTERN int TimeUnit_HOUR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeUnit_HOUR is read-only.");
  return 1;
}


SWIGINTERN PyObject *TimeUnit_HOUR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TimeUnit_HOUR);
  return pyobj;
}


SWIGINTERN int TimeUnit_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeUnit_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *TimeUnit_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TimeUnit_DAY);
  return pyobj;
}


SWIGINTERN int TimeUnit_YEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeUnit_YEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *TimeUnit_YEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TimeUnit_YEAR);
  return pyobj;
}


SWIGINTERN int LegSwapType_MODIFIED_DURATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LegSwapType_MODIFIED_DURATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *LegSwapType_MODIFIED_DURATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LegSwapType_MODIFIED_DURATION));
  return pyobj;
}


SWIGINTERN int LegSwapType_PARFORPAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LegSwapType_PARFORPAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *LegSwapType_PARFORPAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LegSwapType_PARFORPAR));
  return pyobj;
}


SWIGINTERN int LegSwapType_RISK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LegSwapType_RISK is read-only.");
  return 1;
}


SWIGINTERN PyObject *LegSwapType_RISK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LegSwapType_RISK));
  return pyobj;
}


SWIGINTERN int LegSwapType_PAR_FOR_PAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LegSwapType_PAR_FOR_PAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 LegSwapType_MODIFIEDDURATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LegSwapType_MODIFIEDDURATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *LegSwapType_MODIFIEDDURATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LegSwapType_MODIFIEDDURATION));
  return pyobj;
}


SWIGINTERN int LegSwapType_PROCEEDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LegSwapType_PROCEEDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *LegSwapType_PROCEEDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LegSwapType_PROCEEDS));
  return pyobj;
}


SWIGINTERN int IOITransType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOITransType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOITransType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOITransType_REPLACE));
  return pyobj;
}


SWIGINTERN int IOITransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOITransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOITransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOITransType_NEW));
  return pyobj;
}


SWIGINTERN int IOITransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOITransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOITransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOITransType_CANCEL));
  return pyobj;
}


SWIGINTERN int PosReqResult_REQUESTFORPOSITIONNOTSUPPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqResult_REQUESTFORPOSITIONNOTSUPPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosReqResult_REQUESTFORPOSITIONNOTSUPPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqResult_REQUESTFORPOSITIONNOTSUPPORTED));
  return pyobj;
}


SWIGINTERN int PosReqResult_VALID_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqResult_VALID_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosReqResult_VALID_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqResult_VALID_REQUEST));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 PosReqResult_INVALID_OR_UNSUPPORTED_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqResult_INVALID_OR_UNSUPPORTED_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PosReqResult_NOTAUTHORIZEDTOREQUESTPOSITIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqResult_NOTAUTHORIZEDTOREQUESTPOSITIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosReqResult_NOTAUTHORIZEDTOREQUESTPOSITIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqResult_NOTAUTHORIZEDTOREQUESTPOSITIONS));
  return pyobj;
}


SWIGINTERN int PosReqResult_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqResult_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosReqResult_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqResult_OTHER));
  return pyobj;
}


SWIGINTERN int PosReqResult_NOPOSITIONSFOUNDTHATMATCHCRITERIA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqResult_NOPOSITIONSFOUNDTHATMATCHCRITERIA is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosReqResult_NOPOSITIONSFOUNDTHATMATCHCRITERIA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqResult_NOPOSITIONSFOUNDTHATMATCHCRITERIA));
  return pyobj;
}


SWIGINTERN int 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 *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 PosReqResult_INVALIDORUNSUPPORTEDREQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqResult_INVALIDORUNSUPPORTEDREQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosReqResult_INVALIDORUNSUPPORTEDREQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqResult_INVALIDORUNSUPPORTEDREQUEST));
  return pyobj;
}


SWIGINTERN int PosReqResult_VALIDREQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqResult_VALIDREQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosReqResult_VALIDREQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqResult_VALIDREQUEST));
  return pyobj;
}


SWIGINTERN int SettlInstMode_ACCOUNTOVERRIDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstMode_ACCOUNTOVERRIDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlInstMode_ACCOUNTOVERRIDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstMode_ACCOUNTOVERRIDING));
  return pyobj;
}


SWIGINTERN int SettlInstMode_REJECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstMode_REJECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlInstMode_REJECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstMode_REJECT));
  return pyobj;
}


SWIGINTERN int SettlInstMode_DEFAULT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstMode_DEFAULT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlInstMode_DEFAULT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstMode_DEFAULT));
  return pyobj;
}


SWIGINTERN int SettlInstMode_REQUEST_REJECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstMode_REQUEST_REJECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlInstMode_REQUEST_REJECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstMode_REQUEST_REJECT));
  return pyobj;
}


SWIGINTERN int SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_OVERRIDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_OVERRIDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SettlInstMode_SIPROVIDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstMode_SIPROVIDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlInstMode_SIPROVIDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstMode_SIPROVIDED));
  return pyobj;
}


SWIGINTERN int SettlInstMode_ACCOUNTSTANDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstMode_ACCOUNTSTANDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlInstMode_ACCOUNTSTANDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstMode_ACCOUNTSTANDING));
  return pyobj;
}


SWIGINTERN int SettlInstMode_CIVORDERSINGLEACCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstMode_CIVORDERSINGLEACCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlInstMode_CIVORDERSINGLEACCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstMode_CIVORDERSINGLEACCT));
  return pyobj;
}


SWIGINTERN int SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_STANDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_STANDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 SettlInstMode_STANDING_INSTRUCTIONS_PROVIDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstMode_STANDING_INSTRUCTIONS_PROVIDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PreviouslyReported_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PreviouslyReported_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *PreviouslyReported_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PreviouslyReported_NO));
  return pyobj;
}


SWIGINTERN int PreviouslyReported_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PreviouslyReported_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *PreviouslyReported_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PreviouslyReported_YES));
  return pyobj;
}


SWIGINTERN int CustOrderHandlingInst_PEGGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_PEGGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *CustOrderHandlingInst_PEGGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_PEGGED);
  return pyobj;
}


SWIGINTERN int CustOrderHandlingInst_MARKET_ON_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_MARKET_ON_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *CustOrderHandlingInst_MARKET_ON_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_MARKET_ON_OPEN);
  return pyobj;
}


SWIGINTERN int CustOrderHandlingInst_SCALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_SCALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *CustOrderHandlingInst_SCALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_SCALE);
  return pyobj;
}


SWIGINTERN int CustOrderHandlingInst_FILL_OR_KILL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_FILL_OR_KILL is read-only.");
  return 1;
}


SWIGINTERN PyObject *CustOrderHandlingInst_FILL_OR_KILL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_FILL_OR_KILL);
  return pyobj;
}


SWIGINTERN int CustOrderHandlingInst_ALL_OR_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_ALL_OR_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *CustOrderHandlingInst_ALL_OR_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_ALL_OR_NONE);
  return pyobj;
}


SWIGINTERN int CustOrderHandlingInst_NOT_HELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_NOT_HELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *CustOrderHandlingInst_NOT_HELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_NOT_HELD);
  return pyobj;
}


SWIGINTERN int CustOrderHandlingInst_DIRECTED_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_DIRECTED_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *CustOrderHandlingInst_DIRECTED_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_DIRECTED_ORDER);
  return pyobj;
}


SWIGINTERN int CustOrderHandlingInst_STOP_STOCK_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_STOP_STOCK_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *CustOrderHandlingInst_STOP_STOCK_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_STOP_STOCK_TRANSACTION);
  return pyobj;
}


SWIGINTERN int CustOrderHandlingInst_OVER_THE_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_OVER_THE_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *CustOrderHandlingInst_OVER_THE_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_OVER_THE_DAY);
  return pyobj;
}


SWIGINTERN int CustOrderHandlingInst_ADD_ON_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_ADD_ON_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *CustOrderHandlingInst_ADD_ON_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_ADD_ON_ORDER);
  return pyobj;
}


SWIGINTERN int CustOrderHandlingInst_MARKET_AT_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_MARKET_AT_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *CustOrderHandlingInst_MARKET_AT_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_MARKET_AT_CLOSE);
  return pyobj;
}


SWIGINTERN int CustOrderHandlingInst_LIMIT_ON_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_LIMIT_ON_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *CustOrderHandlingInst_LIMIT_ON_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_LIMIT_ON_OPEN);
  return pyobj;
}


SWIGINTERN int CustOrderHandlingInst_CASH_NOT_HELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_CASH_NOT_HELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *CustOrderHandlingInst_CASH_NOT_HELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_CASH_NOT_HELD);
  return pyobj;
}


SWIGINTERN int CustOrderHandlingInst_MARKET_ON_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_MARKET_ON_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *CustOrderHandlingInst_MARKET_ON_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_MARKET_ON_CLOSE);
  return pyobj;
}


SWIGINTERN int CustOrderHandlingInst_TIME_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_TIME_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *CustOrderHandlingInst_TIME_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_TIME_ORDER);
  return pyobj;
}


SWIGINTERN int CustOrderHandlingInst_LIMIT_ON_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_LIMIT_ON_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *CustOrderHandlingInst_LIMIT_ON_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_LIMIT_ON_CLOSE);
  return pyobj;
}


SWIGINTERN int CustOrderHandlingInst_IMMEDIATE_OR_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_IMMEDIATE_OR_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *CustOrderHandlingInst_IMMEDIATE_OR_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_IMMEDIATE_OR_CANCEL);
  return pyobj;
}


SWIGINTERN int CustOrderHandlingInst_TRAILING_STOP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_TRAILING_STOP is read-only.");
  return 1;
}


SWIGINTERN PyObject *CustOrderHandlingInst_TRAILING_STOP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_TRAILING_STOP);
  return pyobj;
}


SWIGINTERN int CustOrderHandlingInst_WORK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_WORK is read-only.");
  return 1;
}


SWIGINTERN PyObject *CustOrderHandlingInst_WORK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_WORK);
  return pyobj;
}


SWIGINTERN int CustOrderHandlingInst_RESERVE_SIZE_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_RESERVE_SIZE_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *CustOrderHandlingInst_RESERVE_SIZE_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_RESERVE_SIZE_ORDER);
  return pyobj;
}


SWIGINTERN int CustOrderHandlingInst_MINIMUM_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_MINIMUM_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *CustOrderHandlingInst_MINIMUM_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_MINIMUM_QUANTITY);
  return pyobj;
}


SWIGINTERN int CustOrderHandlingInst_MARKET_AT_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_MARKET_AT_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *CustOrderHandlingInst_MARKET_AT_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_MARKET_AT_OPEN);
  return pyobj;
}


SWIGINTERN int CustOrderHandlingInst_IMBALANCE_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_IMBALANCE_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *CustOrderHandlingInst_IMBALANCE_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_IMBALANCE_ONLY);
  return pyobj;
}


SWIGINTERN int CustOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *CustOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION);
  return pyobj;
}


SWIGINTERN int SecurityStatus_INACTIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityStatus_INACTIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityStatus_INACTIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityStatus_INACTIVE);
  return pyobj;
}


SWIGINTERN int SecurityStatus_ACTIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityStatus_ACTIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityStatus_ACTIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityStatus_ACTIVE);
  return pyobj;
}


SWIGINTERN int ProcessCode_SOFT_DOLLAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProcessCode_SOFT_DOLLAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *ProcessCode_SOFT_DOLLAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ProcessCode_SOFT_DOLLAR));
  return pyobj;
}


SWIGINTERN int ProcessCode_STEPOUTSOFT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProcessCode_STEPOUTSOFT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ProcessCode_STEPOUTSOFT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ProcessCode_STEPOUTSOFT));
  return pyobj;
}


SWIGINTERN int ProcessCode_STEPOUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProcessCode_STEPOUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ProcessCode_STEPOUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ProcessCode_STEPOUT));
  return pyobj;
}


SWIGINTERN int ProcessCode_PLAN_SPONSOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProcessCode_PLAN_SPONSOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *ProcessCode_PLAN_SPONSOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ProcessCode_PLAN_SPONSOR));
  return pyobj;
}


SWIGINTERN int ProcessCode_STEP_IN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProcessCode_STEP_IN is read-only.");
  return 1;
}


SWIGINTERN PyObject *ProcessCode_STEP_IN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ProcessCode_STEP_IN));
  return pyobj;
}


SWIGINTERN int ProcessCode_STEPIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProcessCode_STEPIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *ProcessCode_STEPIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ProcessCode_STEPIN));
  return pyobj;
}


SWIGINTERN int ProcessCode_REGULAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProcessCode_REGULAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *ProcessCode_REGULAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ProcessCode_REGULAR));
  return pyobj;
}


SWIGINTERN int ProcessCode_SOFTDOLLAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProcessCode_SOFTDOLLAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *ProcessCode_SOFTDOLLAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ProcessCode_SOFTDOLLAR));
  return pyobj;
}


SWIGINTERN int ProcessCode_PLANSPONSOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProcessCode_PLANSPONSOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *ProcessCode_PLANSPONSOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ProcessCode_PLANSPONSOR));
  return pyobj;
}


SWIGINTERN int ProcessCode_STEPINSOFT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProcessCode_STEPINSOFT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ProcessCode_STEPINSOFT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ProcessCode_STEPINSOFT));
  return pyobj;
}


SWIGINTERN int ProcessCode_SOFT_DOLLAR_STEP_OUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProcessCode_SOFT_DOLLAR_STEP_OUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ProcessCode_STEP_OUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProcessCode_STEP_OUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ProcessCode_STEP_OUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ProcessCode_STEP_OUT));
  return pyobj;
}


SWIGINTERN int ProcessCode_SOFT_DOLLAR_STEP_IN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProcessCode_SOFT_DOLLAR_STEP_IN is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_TRY_TO_STOP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_TRY_TO_STOP is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_PEG_TO_LIMIT_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_PEG_TO_LIMIT_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_EXECUTE_AS_DURATION_NEUTRAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_EXECUTE_AS_DURATION_NEUTRAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_PARTICIPANT_DONT_INITIATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_PARTICIPANT_DONT_INITIATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_PARTICIPANT_DONT_INITIATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_PARTICIPANT_DONT_INITIATE));
  return pyobj;
}


SWIGINTERN int ExecInst_REINSTATE_ON_TRADING_HALT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_REINSTATE_ON_TRADING_HALT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_NO_CROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_NO_CROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_NO_CROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_NO_CROSS));
  return pyobj;
}


SWIGINTERN int ExecInst_PEGVWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_PEGVWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_PEGVWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_PEGVWAP));
  return pyobj;
}


SWIGINTERN int ExecInst_STRICT_SCALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_STRICT_SCALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_STRICT_SCALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_STRICT_SCALE));
  return pyobj;
}


SWIGINTERN int ExecInst_AON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_AON is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_AON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_AON));
  return pyobj;
}


SWIGINTERN int ExecInst_TRAILING_STOP_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_TRAILING_STOP_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_TRAILSTOPPEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_TRAILSTOPPEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_TRAILSTOPPEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_TRAILSTOPPEG));
  return pyobj;
}


SWIGINTERN int ExecInst_MARKPEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_MARKPEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_MARKPEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_MARKPEG));
  return pyobj;
}


SWIGINTERN int ExecInst_MIDPRCPEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_MIDPRCPEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_MIDPRCPEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_MIDPRCPEG));
  return pyobj;
}


SWIGINTERN int ExecInst_OKCROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_OKCROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_OKCROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_OKCROSS));
  return pyobj;
}


SWIGINTERN int ExecInst_EXECUTE_AS_FX_NEUTRAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_EXECUTE_AS_FX_NEUTRAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_CUSTDISPINST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_CUSTDISPINST is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_CUSTDISPINST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_CUSTDISPINST));
  return pyobj;
}


SWIGINTERN int ExecInst_IGNOREPRICECHK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_IGNOREPRICECHK is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_IGNOREPRICECHK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_IGNOREPRICECHK));
  return pyobj;
}


SWIGINTERN int ExecInst_STRICTLIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_STRICTLIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_STRICTLIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_STRICTLIMIT));
  return pyobj;
}


SWIGINTERN int ExecInst_WORKTOSTRATEGY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_WORKTOSTRATEGY is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_WORKTOSTRATEGY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_WORKTOSTRATEGY));
  return pyobj;
}


SWIGINTERN int ExecInst_OK_TO_CROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_OK_TO_CROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_SUSPEND_ON_SYSTEM_FAILURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_SUSPEND_ON_SYSTEM_FAILURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_REINSTATE_ON_SYSTEM_FAILURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_REINSTATE_ON_SYSTEM_FAILURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_GO_ALONG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_GO_ALONG is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_GO_ALONG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_GO_ALONG));
  return pyobj;
}


SWIGINTERN int ExecInst_INSTITONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_INSTITONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_INSTITONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_INSTITONLY));
  return pyobj;
}


SWIGINTERN int ExecInst_DO_NOT_INCREASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_DO_NOT_INCREASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_SUSPEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_SUSPEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_SUSPEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_SUSPEND));
  return pyobj;
}


SWIGINTERN int ExecInst_TRYTOSTOP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_TRYTOSTOP is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_TRYTOSTOP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_TRYTOSTOP));
  return pyobj;
}


SWIGINTERN int 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 *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 ExecInst_SUSPEND_ON_TRADING_HALT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_SUSPEND_ON_TRADING_HALT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_INTERMARKET_SWEEP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_INTERMARKET_SWEEP is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_INTERMARKET_SWEEP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_INTERMARKET_SWEEP));
  return pyobj;
}


SWIGINTERN int ExecInst_IGNORE_PRICE_VALIDITY_CHECKS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_IGNORE_PRICE_VALIDITY_CHECKS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_PARTICIPATE_DONT_INITIATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_PARTICIPATE_DONT_INITIATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_LASTPEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_LASTPEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_LASTPEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_LASTPEG));
  return pyobj;
}


SWIGINTERN int ExecInst_PEG_TO_VWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_PEG_TO_VWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_PRIMARY_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_PRIMARY_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_PRIMARY_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_PRIMARY_PEG));
  return pyobj;
}


SWIGINTERN int ExecInst_NONNEGO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_NONNEGO is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_NONNEGO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_NONNEGO));
  return pyobj;
}


SWIGINTERN int ExecInst_BEST_EXECUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_BEST_EXECUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_BEST_EXECUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_BEST_EXECUTION));
  return pyobj;
}


SWIGINTERN int ExecInst_STAY_ON_BID_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_STAY_ON_BID_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_NOTHELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_NOTHELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_NOTHELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_NOTHELD));
  return pyobj;
}


SWIGINTERN int ExecInst_STRICTSCALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_STRICTSCALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_STRICTSCALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_STRICTSCALE));
  return pyobj;
}


SWIGINTERN int ExecInst_REINSTATE_ON_CONNECTION_LOSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_REINSTATE_ON_CONNECTION_LOSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_DNI_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_DNI is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_DNI_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_DNI));
  return pyobj;
}


SWIGINTERN int ExecInst_TRYTOSCALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_TRYTOSCALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_TRYTOSCALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_TRYTOSCALE));
  return pyobj;
}


SWIGINTERN int ExecInst_PERCENT_OF_VOLUME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_PERCENT_OF_VOLUME is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_GOALONG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_GOALONG is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_GOALONG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_GOALONG));
  return pyobj;
}


SWIGINTERN int ExecInst_WORK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_WORK is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_WORK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_WORK));
  return pyobj;
}


SWIGINTERN int ExecInst_HELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_HELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_HELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_HELD));
  return pyobj;
}


SWIGINTERN int ExecInst_NOCROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_NOCROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_NOCROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_NOCROSS));
  return pyobj;
}


SWIGINTERN int ExecInst_RELEASE_FROM_SUSPENSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_RELEASE_FROM_SUSPENSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_STRICT_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_STRICT_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_STRICT_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_STRICT_LIMIT));
  return pyobj;
}


SWIGINTERN int ExecInst_OPENPEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_OPENPEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_OPENPEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_OPENPEG));
  return pyobj;
}


SWIGINTERN int ExecInst_STAY_ON_BIDSIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_STAY_ON_BIDSIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_STAY_ON_OFFERSIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_STAY_ON_OFFERSIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_OVER_THE_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_OVER_THE_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_RESTATEONTRADINGHALT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_RESTATEONTRADINGHALT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_RESTATEONTRADINGHALT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_RESTATEONTRADINGHALT));
  return pyobj;
}


SWIGINTERN int ExecInst_INSTITUTIONS_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_INSTITUTIONS_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_INSTITUTIONS_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_INSTITUTIONS_ONLY));
  return pyobj;
}


SWIGINTERN int ExecInst_NOT_HELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_NOT_HELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_NOT_HELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_NOT_HELD));
  return pyobj;
}


SWIGINTERN int ExecInst_CANCELONTRADINGHALT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_CANCELONTRADINGHALT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_CANCELONTRADINGHALT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_CANCELONTRADINGHALT));
  return pyobj;
}


SWIGINTERN int ExecInst_CANCELONSYSFAIL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_CANCELONSYSFAIL is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_CANCELONSYSFAIL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_CANCELONSYSFAIL));
  return pyobj;
}


SWIGINTERN int ExecInst_CANCEL_ON_SYSTEM_FAILURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_CANCEL_ON_SYSTEM_FAILURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_MARKET_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_MARKET_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_MARKET_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_MARKET_PEG));
  return pyobj;
}


SWIGINTERN int ExecInst_TRADEALONG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_TRADEALONG is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_TRADEALONG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_TRADEALONG));
  return pyobj;
}


SWIGINTERN int ExecInst_CALL_FIRST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_CALL_FIRST is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_CALL_FIRST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_CALL_FIRST));
  return pyobj;
}


SWIGINTERN int ExecInst_PEGTOLIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_PEGTOLIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_PEGTOLIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_PEGTOLIMIT));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 ExecInst_NON_NEGOTIABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_NON_NEGOTIABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_NON_NEGOTIABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_NON_NEGOTIABLE));
  return pyobj;
}


SWIGINTERN int ExecInst_TRY_TO_SCALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_TRY_TO_SCALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_EXTERNAL_ROUTING_ALLOWED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_EXTERNAL_ROUTING_ALLOWED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_WORK_TO_TARGET_STRATEGY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_WORK_TO_TARGET_STRATEGY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_STAY_ON_OFFER_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_STAY_ON_OFFER_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_CUSTOMER_DISPLAY_INSTRUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_CUSTOMER_DISPLAY_INSTRUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_OVERDAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_OVERDAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_OVERDAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_OVERDAY));
  return pyobj;
}


SWIGINTERN int ExecInst_LAST_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_LAST_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_LAST_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_LAST_PEG));
  return pyobj;
}


SWIGINTERN int ExecInst_CALLFIRST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_CALLFIRST is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_CALLFIRST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_CALLFIRST));
  return pyobj;
}


SWIGINTERN int ExecInst_REINSTATE_ON_SYSTEM_FAILUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_REINSTATE_ON_SYSTEM_FAILUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_DO_NOT_REDUCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_DO_NOT_REDUCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_MID_PRICE_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_MID_PRICE_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_ALL_OR_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_ALL_OR_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_OPENING_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_OPENING_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_OPENING_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_OPENING_PEG));
  return pyobj;
}


SWIGINTERN int ExecInst_PERCVOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_PERCVOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_PERCVOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_PERCVOL));
  return pyobj;
}


SWIGINTERN int ExecInst_SUSPEND_ON_CONNECTION_LOSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_SUSPEND_ON_CONNECTION_LOSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_CANCEL_ON_CONNECTION_LOSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_CANCEL_ON_CONNECTION_LOSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_EXTERNAL_ROUTING_NOT_ALLOWED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_EXTERNAL_ROUTING_NOT_ALLOWED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_CANCEL_IF_NOT_BEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_CANCEL_IF_NOT_BEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_PARTNOTINIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_PARTNOTINIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_PARTNOTINIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_PARTNOTINIT));
  return pyobj;
}


SWIGINTERN int ExecInst_CXLIFNOTBEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_CXLIFNOTBEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_CXLIFNOTBEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_CXLIFNOTBEST));
  return pyobj;
}


SWIGINTERN int ExecInst_NETTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_NETTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_NETTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_NETTING));
  return pyobj;
}


SWIGINTERN int ExecInst_IMBALANCE_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_IMBALANCE_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_IMBALANCE_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_IMBALANCE_ONLY));
  return pyobj;
}


SWIGINTERN int ExecInst_CANCEL_ON_TRADING_HALT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_CANCEL_ON_TRADING_HALT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecInst_TRADE_ALONG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_TRADE_ALONG is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_TRADE_ALONG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_TRADE_ALONG));
  return pyobj;
}


SWIGINTERN int ExecInst_DNR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_DNR is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_DNR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_DNR));
  return pyobj;
}


SWIGINTERN int ExecInst_STAYOFFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_STAYOFFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_STAYOFFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_STAYOFFER));
  return pyobj;
}


SWIGINTERN int ExecInst_STAYBID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_STAYBID is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_STAYBID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_STAYBID));
  return pyobj;
}


SWIGINTERN int ExecInst_RESTATEONSYSFAIL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_RESTATEONSYSFAIL is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_RESTATEONSYSFAIL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_RESTATEONSYSFAIL));
  return pyobj;
}


SWIGINTERN int ExecInst_PRIMPEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_PRIMPEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecInst_PRIMPEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_PRIMPEG));
  return pyobj;
}


SWIGINTERN int ExecType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_REPLACE));
  return pyobj;
}


SWIGINTERN int ExecType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_NEW));
  return pyobj;
}


SWIGINTERN int ExecType_CALCULATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_CALCULATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecType_CALCULATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_CALCULATED));
  return pyobj;
}


SWIGINTERN int ExecType_PENDINGNEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_PENDINGNEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecType_PENDINGNEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_PENDINGNEW));
  return pyobj;
}


SWIGINTERN int ExecType_ORDERSTATUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_ORDERSTATUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecType_ORDERSTATUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_ORDERSTATUS));
  return pyobj;
}


SWIGINTERN int ExecType_PENDING_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_PENDING_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecType_PENDING_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_PENDING_CANCEL));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 ExecType_ORDER_STATUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_ORDER_STATUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecType_ORDER_STATUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_ORDER_STATUS));
  return pyobj;
}


SWIGINTERN int ExecType_PENDING_CANCEL_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_PENDING_CANCEL_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecType_PARTIAL_FILL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_PARTIAL_FILL is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecType_PARTIAL_FILL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_PARTIAL_FILL));
  return pyobj;
}


SWIGINTERN int ExecType_PENDINGCXL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_PENDINGCXL is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecType_PENDINGCXL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_PENDINGCXL));
  return pyobj;
}


SWIGINTERN int ExecType_PENDING_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_PENDING_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecType_PENDING_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_PENDING_NEW));
  return pyobj;
}


SWIGINTERN int ExecType_STOPPED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_STOPPED is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecType_STOPPED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_STOPPED));
  return pyobj;
}


SWIGINTERN int ExecType_CANCELED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_CANCELED is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecType_CANCELED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_CANCELED));
  return pyobj;
}


SWIGINTERN int ExecType_PENDING_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_PENDING_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecType_PENDING_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_PENDING_REPLACE));
  return pyobj;
}


SWIGINTERN int ExecType_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecType_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_TRADE));
  return pyobj;
}


SWIGINTERN int ExecType_TRADE_CORRECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_TRADE_CORRECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecType_TRADE_CORRECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_TRADE_CORRECT));
  return pyobj;
}


SWIGINTERN int ExecType_PENDINGREPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_PENDINGREPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecType_PENDINGREPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_PENDINGREPLACE));
  return pyobj;
}


SWIGINTERN int ExecType_SUSPENDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_SUSPENDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecType_SUSPENDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_SUSPENDED));
  return pyobj;
}


SWIGINTERN int ExecType_FILL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_FILL is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecType_FILL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_FILL));
  return pyobj;
}


SWIGINTERN int ExecType_DONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_DONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecType_DONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_DONE));
  return pyobj;
}


SWIGINTERN int ExecType_RESTATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_RESTATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecType_RESTATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_RESTATED));
  return pyobj;
}


SWIGINTERN int ExecType_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecType_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_REJECTED));
  return pyobj;
}


SWIGINTERN int ExecType_REPLACED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_REPLACED is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecType_REPLACED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_REPLACED));
  return pyobj;
}


SWIGINTERN int ExecType_EXPIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_EXPIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecType_EXPIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_EXPIRED));
  return pyobj;
}


SWIGINTERN int ExecType_DONE_FOR_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_DONE_FOR_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 ExecType_TRADECORRECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_TRADECORRECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecType_TRADECORRECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_TRADECORRECT));
  return pyobj;
}


SWIGINTERN int ExecType_TRADECANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_TRADECANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecType_TRADECANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_TRADECANCEL));
  return pyobj;
}


SWIGINTERN int ExecType_TRADE_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_TRADE_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecType_TRADE_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_TRADE_CANCEL));
  return pyobj;
}


SWIGINTERN int ExecType_CANCELLED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_CANCELLED is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecType_CANCELLED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_CANCELLED));
  return pyobj;
}


SWIGINTERN int MultilegModel_USER_DEFINED_MULTLEG_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultilegModel_USER_DEFINED_MULTLEG_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MultilegModel_PREDEFINED_MULTILEG_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultilegModel_PREDEFINED_MULTILEG_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 EventType_SWAP_NEXT_START_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_SWAP_NEXT_START_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 EventType_LAST_ELIGIBLE_TRADE_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_LAST_ELIGIBLE_TRADE_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 EventType_FIRST_DELIVERY_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_FIRST_DELIVERY_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 EventType_TENDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_TENDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *EventType_TENDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_TENDER));
  return pyobj;
}


SWIGINTERN int EventType_INITIAL_INVENTORY_DUE_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_INITIAL_INVENTORY_DUE_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 EventType_FIRST_INTENT_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_FIRST_INTENT_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 EventType_ACTIVATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_ACTIVATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *EventType_ACTIVATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_ACTIVATION));
  return pyobj;
}


SWIGINTERN int EventType_PUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_PUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *EventType_PUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_PUT));
  return pyobj;
}


SWIGINTERN int EventType_SWAP_START_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_SWAP_START_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 EventType_SWAP_NEXT_ROLL_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_SWAP_NEXT_ROLL_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 EventType_LAST_DELIVERY_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_LAST_DELIVERY_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 EventType_POSITION_REMOVAL_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_POSITION_REMOVAL_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 EventType_SWAP_ROLL_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_SWAP_ROLL_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 EventType_FINAL_INVENTORY_DUE_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_FINAL_INVENTORY_DUE_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 EventType_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *EventType_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_OTHER));
  return pyobj;
}


SWIGINTERN int EventType_INACTIVIATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_INACTIVIATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *EventType_INACTIVIATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_INACTIVIATION));
  return pyobj;
}


SWIGINTERN int EventType_SINKINGFUNDCALL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_SINKINGFUNDCALL is read-only.");
  return 1;
}


SWIGINTERN PyObject *EventType_SINKINGFUNDCALL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_SINKINGFUNDCALL));
  return pyobj;
}


SWIGINTERN int EventType_SWAP_END_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_SWAP_END_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 EventType_LAST_INTENT_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_LAST_INTENT_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 EventType_SINKING_FUND_CALL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_SINKING_FUND_CALL is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 EventType_CALL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_CALL is read-only.");
  return 1;
}


SWIGINTERN PyObject *EventType_CALL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_CALL));
  return pyobj;
}


SWIGINTERN int TradeAllocIndicator_ALLOCATIONREQUIREDALLOCATIONINFORMATIONNOTPROVIDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAllocIndicator_ALLOCATIONREQUIREDALLOCATIONINFORMATIONNOTPROVIDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeAllocIndicator_ALLOCATIONREQUIREDALLOCATIONINFORMATIONNOTPROVIDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeAllocIndicator_ALLOCATIONREQUIREDALLOCATIONINFORMATIONNOTPROVIDED));
  return pyobj;
}


SWIGINTERN int TradeAllocIndicator_ALLOCATION_REQUIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAllocIndicator_ALLOCATION_REQUIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeAllocIndicator_ALLOCATION_REQUIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeAllocIndicator_ALLOCATION_REQUIRED));
  return pyobj;
}


SWIGINTERN int TradeAllocIndicator_ALLOCATION_TO_CLAIM_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAllocIndicator_ALLOCATION_TO_CLAIM_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TradeAllocIndicator_USEALLOCATIONPROVIDEDWITHTHETRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAllocIndicator_USEALLOCATIONPROVIDEDWITHTHETRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeAllocIndicator_USEALLOCATIONPROVIDEDWITHTHETRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeAllocIndicator_USEALLOCATIONPROVIDEDWITHTHETRADE));
  return pyobj;
}


SWIGINTERN int TradeAllocIndicator_ALLOCATION_FROM_EXECUTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAllocIndicator_ALLOCATION_FROM_EXECUTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 TradeAllocIndicator_ALLOCATIONNOTREQUIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAllocIndicator_ALLOCATIONNOTREQUIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeAllocIndicator_ALLOCATIONNOTREQUIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeAllocIndicator_ALLOCATIONNOTREQUIRED));
  return pyobj;
}


SWIGINTERN int TradeAllocIndicator_ALLOCATION_NOT_REQUIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAllocIndicator_ALLOCATION_NOT_REQUIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TradeAllocIndicator_ALLOCATION_GIVE_UP_EXECUTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAllocIndicator_ALLOCATION_GIVE_UP_EXECUTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 UserStatus_NOT_LOGGED_IN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserStatus_NOT_LOGGED_IN is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 UserStatus_PASSWORD_INCORRECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserStatus_PASSWORD_INCORRECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *UserStatus_PASSWORD_INCORRECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserStatus_PASSWORD_INCORRECT));
  return pyobj;
}


SWIGINTERN int UserStatus_USERNOTRECOGNISED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserStatus_USERNOTRECOGNISED is read-only.");
  return 1;
}


SWIGINTERN PyObject *UserStatus_USERNOTRECOGNISED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserStatus_USERNOTRECOGNISED));
  return pyobj;
}


SWIGINTERN int UserStatus_LOGGED_IN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserStatus_LOGGED_IN is read-only.");
  return 1;
}


SWIGINTERN PyObject *UserStatus_LOGGED_IN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserStatus_LOGGED_IN));
  return pyobj;
}


SWIGINTERN int UserStatus_PASSWORDCHANGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserStatus_PASSWORDCHANGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *UserStatus_PASSWORDCHANGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserStatus_PASSWORDCHANGED));
  return pyobj;
}


SWIGINTERN int 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 *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 UserStatus_USER_NOT_RECOGNISED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserStatus_USER_NOT_RECOGNISED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 UserStatus_NOTLOGGEDIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserStatus_NOTLOGGEDIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *UserStatus_NOTLOGGEDIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserStatus_NOTLOGGEDIN));
  return pyobj;
}


SWIGINTERN int UserStatus_PASSWORD_CHANGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserStatus_PASSWORD_CHANGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *UserStatus_PASSWORD_CHANGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserStatus_PASSWORD_CHANGED));
  return pyobj;
}


SWIGINTERN int UserStatus_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserStatus_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *UserStatus_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserStatus_OTHER));
  return pyobj;
}


SWIGINTERN int UserStatus_LOGGEDIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserStatus_LOGGEDIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *UserStatus_LOGGEDIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserStatus_LOGGEDIN));
  return pyobj;
}


SWIGINTERN int UserStatus_SESSION_SHUTDOWN_WARNING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserStatus_SESSION_SHUTDOWN_WARNING is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 UserStatus_PASSWORDINCORRECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserStatus_PASSWORDINCORRECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *UserStatus_PASSWORDINCORRECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserStatus_PASSWORDINCORRECT));
  return pyobj;
}


SWIGINTERN int InstrRegistry_PHYSICAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrRegistry_PHYSICAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrRegistry_PHYSICAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::InstrRegistry_PHYSICAL);
  return pyobj;
}


SWIGINTERN int InstrRegistry_COUNTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrRegistry_COUNTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrRegistry_COUNTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::InstrRegistry_COUNTRY);
  return pyobj;
}


SWIGINTERN int InstrRegistry_CUSTODIAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrRegistry_CUSTODIAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrRegistry_CUSTODIAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::InstrRegistry_CUSTODIAN);
  return pyobj;
}


SWIGINTERN int OrderDelayUnit_WEEKS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_WEEKS is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderDelayUnit_WEEKS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_WEEKS));
  return pyobj;
}


SWIGINTERN int OrderDelayUnit_TENTHS_OF_A_SECOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_TENTHS_OF_A_SECOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 OrderDelayUnit_SECONDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_SECONDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderDelayUnit_SECONDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_SECONDS));
  return pyobj;
}


SWIGINTERN int OrderDelayUnit_MONTHS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_MONTHS is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderDelayUnit_MONTHS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_MONTHS));
  return pyobj;
}


SWIGINTERN int OrderDelayUnit_YEARS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_YEARS is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderDelayUnit_YEARS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_YEARS));
  return pyobj;
}


SWIGINTERN int OrderDelayUnit_NANOSECONDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_NANOSECONDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderDelayUnit_NANOSECONDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_NANOSECONDS));
  return pyobj;
}


SWIGINTERN int OrderDelayUnit_HUNDREDTHS_OF_A_SECOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_HUNDREDTHS_OF_A_SECOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 OrderDelayUnit_HOURS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_HOURS is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderDelayUnit_HOURS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_HOURS));
  return pyobj;
}


SWIGINTERN int OrderDelayUnit_MICROSECONDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_MICROSECONDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderDelayUnit_MICROSECONDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_MICROSECONDS));
  return pyobj;
}


SWIGINTERN int OrderDelayUnit_MINUTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_MINUTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderDelayUnit_MINUTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_MINUTES));
  return pyobj;
}


SWIGINTERN int OrderDelayUnit_MILLISECONDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_MILLISECONDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderDelayUnit_MILLISECONDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_MILLISECONDS));
  return pyobj;
}


SWIGINTERN int OrderDelayUnit_DAYS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_DAYS is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrderDelayUnit_DAYS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_DAYS));
  return pyobj;
}


SWIGINTERN int TradedFlatSwitch_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradedFlatSwitch_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradedFlatSwitch_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradedFlatSwitch_NO));
  return pyobj;
}


SWIGINTERN int TradedFlatSwitch_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradedFlatSwitch_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradedFlatSwitch_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradedFlatSwitch_YES));
  return pyobj;
}


SWIGINTERN int TrdRptStatus_ACCEPTED_WITH_ERRORS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRptStatus_ACCEPTED_WITH_ERRORS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TrdRptStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRptStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdRptStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRptStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int TrdRptStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRptStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *TrdRptStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRptStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int QuoteStatus_CANCELEDDUETOLOCKMARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_CANCELEDDUETOLOCKMARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteStatus_CANCELEDDUETOLOCKMARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CANCELEDDUETOLOCKMARKET));
  return pyobj;
}


SWIGINTERN int QuoteStatus_REJ_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_REJ is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteStatus_REJ_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_REJ));
  return pyobj;
}


SWIGINTERN int QuoteStatus_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteStatus_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_PENDING));
  return pyobj;
}


SWIGINTERN int QuoteStatus_LOCKEDMARKETWARNING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_LOCKEDMARKETWARNING is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteStatus_LOCKEDMARKETWARNING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_LOCKEDMARKETWARNING));
  return pyobj;
}


SWIGINTERN int QuoteStatus_CROSSMARKETWARNING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_CROSSMARKETWARNING is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteStatus_CROSSMARKETWARNING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CROSSMARKETWARNING));
  return pyobj;
}


SWIGINTERN int QuoteStatus_REMOVED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_REMOVED is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteStatus_REMOVED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_REMOVED));
  return pyobj;
}


SWIGINTERN int QuoteStatus_CXLUNDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_CXLUNDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteStatus_CXLUNDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CXLUNDER));
  return pyobj;
}


SWIGINTERN int QuoteStatus_PENDING_END_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_PENDING_END_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 QuoteStatus_CROSS_MARKET_WARNING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_CROSS_MARKET_WARNING is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 QuoteStatus_QUOTENOTFOUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_QUOTENOTFOUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteStatus_QUOTENOTFOUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_QUOTENOTFOUND));
  return pyobj;
}


SWIGINTERN int QuoteStatus_CANCELED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_CANCELED is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteStatus_CANCELED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CANCELED));
  return pyobj;
}


SWIGINTERN int QuoteStatus_LOCKED_MARKET_WARNING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_LOCKED_MARKET_WARNING is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 QuoteStatus_CXLSYM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_CXLSYM is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteStatus_CXLSYM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CXLSYM));
  return pyobj;
}


SWIGINTERN int QuoteStatus_CANCELED_FOR_UNDERLYING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_CANCELED_FOR_UNDERLYING is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 QuoteStatus_UNSOLICITED_QUOTE_REPLENISHMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_UNSOLICITED_QUOTE_REPLENISHMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 QuoteStatus_TOO_LATE_TO_END_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_TOO_LATE_TO_END is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 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 *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 QuoteStatus_ACCPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_ACCPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteStatus_ACCPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_ACCPT));
  return pyobj;
}


SWIGINTERN int QuoteStatus_CANCELED_FOR_SECURITY_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_CANCELED_FOR_SECURITY_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 QuoteStatus_CANCELED_ALL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_CANCELED_ALL is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteStatus_CANCELED_ALL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CANCELED_ALL));
  return pyobj;
}


SWIGINTERN int QuoteStatus_PASS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_PASS is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteStatus_PASS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_PASS));
  return pyobj;
}


SWIGINTERN int QuoteStatus_CANCELEDDUETOCROSSMARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_CANCELEDDUETOCROSSMARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteStatus_CANCELEDDUETOCROSSMARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CANCELEDDUETOCROSSMARKET));
  return pyobj;
}


SWIGINTERN int QuoteStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int QuoteStatus_QUERY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_QUERY is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteStatus_QUERY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_QUERY));
  return pyobj;
}


SWIGINTERN int QuoteStatus_CXLSECTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_CXLSECTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteStatus_CXLSECTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CXLSECTYPE));
  return pyobj;
}


SWIGINTERN int QuoteStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int QuoteStatus_EXPIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_EXPIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteStatus_EXPIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_EXPIRED));
  return pyobj;
}


SWIGINTERN int QuoteStatus_CANCELED_FOR_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_CANCELED_FOR_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 QuoteStatus_REMOVED_FROM_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_REMOVED_FROM_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 QuoteStatus_ACTIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_ACTIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteStatus_ACTIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_ACTIVE));
  return pyobj;
}


SWIGINTERN int QuoteStatus_CANCEL_FOR_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_CANCEL_FOR_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 QuoteStatus_CXLALL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_CXLALL is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteStatus_CXLALL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CXLALL));
  return pyobj;
}


SWIGINTERN int QuoteStatus_QUOTE_NOT_FOUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_QUOTE_NOT_FOUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SolicitedFlag_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SolicitedFlag_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *SolicitedFlag_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SolicitedFlag_NO));
  return pyobj;
}


SWIGINTERN int SolicitedFlag_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SolicitedFlag_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *SolicitedFlag_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SolicitedFlag_YES));
  return pyobj;
}


SWIGINTERN int RiskLimitType_GROSS_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitType_GROSS_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *RiskLimitType_GROSS_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitType_GROSS_LIMIT));
  return pyobj;
}


SWIGINTERN int RiskLimitType_SHORT_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitType_SHORT_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *RiskLimitType_SHORT_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitType_SHORT_LIMIT));
  return pyobj;
}


SWIGINTERN int RiskLimitType_LONG_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitType_LONG_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *RiskLimitType_LONG_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitType_LONG_LIMIT));
  return pyobj;
}


SWIGINTERN int RiskLimitType_NET_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitType_NET_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *RiskLimitType_NET_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitType_NET_LIMIT));
  return pyobj;
}


SWIGINTERN int RiskLimitType_EXPOSURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskLimitType_EXPOSURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *RiskLimitType_EXPOSURE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskLimitType_EXPOSURE));
  return pyobj;
}


SWIGINTERN int ShortSaleReason_DEALER_SOLD_SHORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleReason_DEALER_SOLD_SHORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ShortSaleReason_DEALERSOLDSHORTEXEMPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleReason_DEALERSOLDSHORTEXEMPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ShortSaleReason_DEALERSOLDSHORTEXEMPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleReason_DEALERSOLDSHORTEXEMPT));
  return pyobj;
}


SWIGINTERN int 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 *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 ShortSaleReason_DEALERSOLDSHORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleReason_DEALERSOLDSHORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ShortSaleReason_DEALERSOLDSHORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleReason_DEALERSOLDSHORT));
  return pyobj;
}


SWIGINTERN int ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 ShortSaleReason_SELLINGCUSTOMERSOLDSHORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleReason_SELLINGCUSTOMERSOLDSHORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ShortSaleReason_SELLINGCUSTOMERSOLDSHORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleReason_SELLINGCUSTOMERSOLDSHORT));
  return pyobj;
}


SWIGINTERN int ShortSaleReason_SELLINGCUSTOMERSOLDSHORTEXEMPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleReason_SELLINGCUSTOMERSOLDSHORTEXEMPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ShortSaleReason_SELLINGCUSTOMERSOLDSHORTEXEMPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleReason_SELLINGCUSTOMERSOLDSHORTEXEMPT));
  return pyobj;
}


SWIGINTERN int ShortSaleReason_DEALER_SOLD_SHORT_EXEMPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleReason_DEALER_SOLD_SHORT_EXEMPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ShortSaleReason_QSRORAGUCONTRASIDESOLDSHORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleReason_QSRORAGUCONTRASIDESOLDSHORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ShortSaleReason_QSRORAGUCONTRASIDESOLDSHORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleReason_QSRORAGUCONTRASIDESOLDSHORT));
  return pyobj;
}


SWIGINTERN int ShortSaleReason_QUALIFIED_SERVICE_REPRESENTATIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleReason_QUALIFIED_SERVICE_REPRESENTATIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ShortSaleReason_QSRORAGUCONTRASIDESOLDSHORTEXEMPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleReason_QSRORAGUCONTRASIDESOLDSHORTEXEMPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ShortSaleReason_QSRORAGUCONTRASIDESOLDSHORTEXEMPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleReason_QSRORAGUCONTRASIDESOLDSHORTEXEMPT));
  return pyobj;
}


SWIGINTERN int PegRoundDirection_MOREPASSIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegRoundDirection_MOREPASSIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PegRoundDirection_MOREPASSIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegRoundDirection_MOREPASSIVE));
  return pyobj;
}


SWIGINTERN int PegRoundDirection_MOREAGGRESSIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegRoundDirection_MOREAGGRESSIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PegRoundDirection_MOREAGGRESSIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegRoundDirection_MOREAGGRESSIVE));
  return pyobj;
}


SWIGINTERN int PegRoundDirection_MORE_AGGRESSIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegRoundDirection_MORE_AGGRESSIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PegRoundDirection_MORE_AGGRESSIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegRoundDirection_MORE_AGGRESSIVE));
  return pyobj;
}


SWIGINTERN int PegRoundDirection_MORE_PASSIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegRoundDirection_MORE_PASSIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PegRoundDirection_MORE_PASSIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegRoundDirection_MORE_PASSIVE));
  return pyobj;
}


SWIGINTERN int ModelType_PROPRIETARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ModelType_PROPRIETARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *ModelType_PROPRIETARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ModelType_PROPRIETARY));
  return pyobj;
}


SWIGINTERN int ModelType_UTILITY_PROVIDED_STANDARD_MODEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ModelType_UTILITY_PROVIDED_STANDARD_MODEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 FuturesValuationMethod_PREMIUM_STYLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FuturesValuationMethod_PREMIUM_STYLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *FuturesValuationMethod_PREMIUM_STYLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::FuturesValuationMethod_PREMIUM_STYLE);
  return pyobj;
}


SWIGINTERN int 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 *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 SettlMethod_CASH_SETTLEMENT_REQUIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlMethod_CASH_SETTLEMENT_REQUIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SettlMethod_PHYSICAL_SETTLEMENT_REQUIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlMethod_PHYSICAL_SETTLEMENT_REQUIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ConfirmStatus_CONFIRMED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmStatus_CONFIRMED is read-only.");
  return 1;
}


SWIGINTERN PyObject *ConfirmStatus_CONFIRMED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmStatus_CONFIRMED));
  return pyobj;
}


SWIGINTERN int ConfirmStatus_REQUESTREJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmStatus_REQUESTREJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *ConfirmStatus_REQUESTREJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmStatus_REQUESTREJECTED));
  return pyobj;
}


SWIGINTERN int ConfirmStatus_MISSINGSETTLEMENTINSTRUCTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmStatus_MISSINGSETTLEMENTINSTRUCTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *ConfirmStatus_MISSINGSETTLEMENTINSTRUCTIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmStatus_MISSINGSETTLEMENTINSTRUCTIONS));
  return pyobj;
}


SWIGINTERN int ConfirmStatus_MISSING_SETTLEMENT_INSTRUCTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmStatus_MISSING_SETTLEMENT_INSTRUCTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ConfirmStatus_REQUEST_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmStatus_REQUEST_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *ConfirmStatus_REQUEST_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmStatus_REQUEST_REJECTED));
  return pyobj;
}


SWIGINTERN int ConfirmStatus_MISMATCHEDACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmStatus_MISMATCHEDACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ConfirmStatus_MISMATCHEDACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmStatus_MISMATCHEDACCOUNT));
  return pyobj;
}


SWIGINTERN int ConfirmStatus_MISMATCHED_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmStatus_MISMATCHED_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ConfirmStatus_MISMATCHED_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmStatus_MISMATCHED_ACCOUNT));
  return pyobj;
}


SWIGINTERN int ConfirmStatus_RECEIVED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmStatus_RECEIVED is read-only.");
  return 1;
}


SWIGINTERN PyObject *ConfirmStatus_RECEIVED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmStatus_RECEIVED));
  return pyobj;
}


SWIGINTERN int LocateReqd_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LocateReqd_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *LocateReqd_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LocateReqd_NO));
  return pyobj;
}


SWIGINTERN int LocateReqd_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LocateReqd_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *LocateReqd_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LocateReqd_YES));
  return pyobj;
}


SWIGINTERN int Adjustment_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Adjustment_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Adjustment_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Adjustment_CANCEL));
  return pyobj;
}


SWIGINTERN int Adjustment_CORRECTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Adjustment_CORRECTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Adjustment_CORRECTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Adjustment_CORRECTION));
  return pyobj;
}


SWIGINTERN int Adjustment_ERROR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Adjustment_ERROR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Adjustment_ERROR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Adjustment_ERROR));
  return pyobj;
}


SWIGINTERN int StreamAsgnType_ASSIGNMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnType_ASSIGNMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *StreamAsgnType_ASSIGNMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamAsgnType_ASSIGNMENT));
  return pyobj;
}


SWIGINTERN int StreamAsgnType_TERMINATE_UNASSIGN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnType_TERMINATE_UNASSIGN is read-only.");
  return 1;
}


SWIGINTERN PyObject *StreamAsgnType_TERMINATE_UNASSIGN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamAsgnType_TERMINATE_UNASSIGN));
  return pyobj;
}


SWIGINTERN int StreamAsgnType_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnType_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *StreamAsgnType_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamAsgnType_REJECTED));
  return pyobj;
}


SWIGINTERN int LastRptRequested_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastRptRequested_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *LastRptRequested_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LastRptRequested_NO));
  return pyobj;
}


SWIGINTERN int LastRptRequested_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastRptRequested_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *LastRptRequested_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LastRptRequested_YES));
  return pyobj;
}


SWIGINTERN int SettlSessID_END_OF_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlSessID_END_OF_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlSessID_END_OF_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlSessID_END_OF_DAY);
  return pyobj;
}


SWIGINTERN int SettlSessID_REGULAR_TRADING_HOURS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlSessID_REGULAR_TRADING_HOURS is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlSessID_REGULAR_TRADING_HOURS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlSessID_REGULAR_TRADING_HOURS);
  return pyobj;
}


SWIGINTERN int SettlSessID_ELECTRONIC_TRADING_HOURS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlSessID_ELECTRONIC_TRADING_HOURS is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlSessID_ELECTRONIC_TRADING_HOURS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlSessID_ELECTRONIC_TRADING_HOURS);
  return pyobj;
}


SWIGINTERN int SettlSessID_INTRADAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlSessID_INTRADAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlSessID_INTRADAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlSessID_INTRADAY);
  return pyobj;
}


SWIGINTERN int TradeReportType_NO_WAS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_NO_WAS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeReportType_NO_WAS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_NO_WAS));
  return pyobj;
}


SWIGINTERN int TradeReportType_ADDENDUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_ADDENDUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeReportType_ADDENDUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ADDENDUM));
  return pyobj;
}


SWIGINTERN int TradeReportType_7_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_7 is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeReportType_7_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_7));
  return pyobj;
}


SWIGINTERN int TradeReportType_PENDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_PENDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeReportType_PENDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_PENDED));
  return pyobj;
}


SWIGINTERN int TradeReportType_LOCKEDINTRADEBREAK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_LOCKEDINTRADEBREAK is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeReportType_LOCKEDINTRADEBREAK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_LOCKEDINTRADEBREAK));
  return pyobj;
}


SWIGINTERN int TradeReportType_DEFAULTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_DEFAULTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeReportType_DEFAULTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_DEFAULTED));
  return pyobj;
}


SWIGINTERN int TradeReportType_DECLINE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_DECLINE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeReportType_DECLINE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_DECLINE));
  return pyobj;
}


SWIGINTERN int TradeReportType_ALLEGED_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_ALLEGED_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeReportType_ALLEGED_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ALLEGED_NEW));
  return pyobj;
}


SWIGINTERN int TradeReportType_ALLEGED_TRADE_REPORT_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_ALLEGED_TRADE_REPORT_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TradeReportType_ALLEGED_15_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_ALLEGED_15 is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeReportType_ALLEGED_15_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ALLEGED_15));
  return pyobj;
}


SWIGINTERN int TradeReportType_ALLEGED_ADDENDUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_ALLEGED_ADDENDUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeReportType_ALLEGED_ADDENDUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ALLEGED_ADDENDUM));
  return pyobj;
}


SWIGINTERN int TradeReportType_ALLEGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_ALLEGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeReportType_ALLEGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ALLEGED));
  return pyobj;
}


SWIGINTERN int TradeReportType_SUBMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_SUBMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeReportType_SUBMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_SUBMIT));
  return pyobj;
}


SWIGINTERN int TradeReportType_NOWAS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_NOWAS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeReportType_NOWAS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_NOWAS));
  return pyobj;
}


SWIGINTERN int TradeReportType_ALLEGED_1_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_ALLEGED_1 is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeReportType_ALLEGED_1_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ALLEGED_1));
  return pyobj;
}


SWIGINTERN int TradeReportType_INVALID_CMTA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_INVALID_CMTA is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeReportType_INVALID_CMTA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_INVALID_CMTA));
  return pyobj;
}


SWIGINTERN int TradeReportType_TRADEREPORTCANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_TRADEREPORTCANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeReportType_TRADEREPORTCANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_TRADEREPORTCANCEL));
  return pyobj;
}


SWIGINTERN int TradeReportType_TRADE_REPORT_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_TRADE_REPORT_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TradeReportType_ALLEGED_NO_WAS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_ALLEGED_NO_WAS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TradeReportType_ACCEPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_ACCEPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeReportType_ACCEPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ACCEPT));
  return pyobj;
}


SWIGINTERN int ExerciseStyle_AMERICAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExerciseStyle_AMERICAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExerciseStyle_AMERICAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExerciseStyle_AMERICAN));
  return pyobj;
}


SWIGINTERN int ExerciseStyle_EUROPEAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExerciseStyle_EUROPEAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExerciseStyle_EUROPEAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExerciseStyle_EUROPEAN));
  return pyobj;
}


SWIGINTERN int ExerciseStyle_BERMUDA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExerciseStyle_BERMUDA is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExerciseStyle_BERMUDA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExerciseStyle_BERMUDA));
  return pyobj;
}


SWIGINTERN int HaltReasonChar_EQUIPCHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonChar_EQUIPCHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *HaltReasonChar_EQUIPCHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_EQUIPCHANGE));
  return pyobj;
}


SWIGINTERN int HaltReasonChar_ADDITIONAL_INFORMATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonChar_ADDITIONAL_INFORMATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *HaltReasonChar_ADDITIONAL_INFORMATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_ADDITIONAL_INFORMATION));
  return pyobj;
}


SWIGINTERN int HaltReasonChar_ORDINFL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonChar_ORDINFL is read-only.");
  return 1;
}


SWIGINTERN PyObject *HaltReasonChar_ORDINFL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_ORDINFL));
  return pyobj;
}


SWIGINTERN int HaltReasonChar_NEW_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonChar_NEW_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *HaltReasonChar_NEW_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_NEW_PENDING));
  return pyobj;
}


SWIGINTERN int HaltReasonChar_NEWSDISS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonChar_NEWSDISS is read-only.");
  return 1;
}


SWIGINTERN PyObject *HaltReasonChar_NEWSDISS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_NEWSDISS));
  return pyobj;
}


SWIGINTERN int HaltReasonChar_NEWS_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonChar_NEWS_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *HaltReasonChar_NEWS_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_NEWS_PENDING));
  return pyobj;
}


SWIGINTERN int HaltReasonChar_ORDER_INFLUX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonChar_ORDER_INFLUX is read-only.");
  return 1;
}


SWIGINTERN PyObject *HaltReasonChar_ORDER_INFLUX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_ORDER_INFLUX));
  return pyobj;
}


SWIGINTERN int HaltReasonChar_NEWS_DISSEMINATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonChar_NEWS_DISSEMINATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *HaltReasonChar_NEWS_DISSEMINATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_NEWS_DISSEMINATION));
  return pyobj;
}


SWIGINTERN int HaltReasonChar_ADDINFO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonChar_ADDINFO is read-only.");
  return 1;
}


SWIGINTERN PyObject *HaltReasonChar_ADDINFO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_ADDINFO));
  return pyobj;
}


SWIGINTERN int HaltReasonChar_ORDIMB_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonChar_ORDIMB is read-only.");
  return 1;
}


SWIGINTERN PyObject *HaltReasonChar_ORDIMB_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_ORDIMB));
  return pyobj;
}


SWIGINTERN int HaltReasonChar_EQUIPMENT_CHANGEOVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonChar_EQUIPMENT_CHANGEOVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *HaltReasonChar_EQUIPMENT_CHANGEOVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_EQUIPMENT_CHANGEOVER));
  return pyobj;
}


SWIGINTERN int HaltReasonChar_ORDER_IMBALANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonChar_ORDER_IMBALANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *HaltReasonChar_ORDER_IMBALANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_ORDER_IMBALANCE));
  return pyobj;
}


SWIGINTERN int HaltReasonChar_NEWSPEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonChar_NEWSPEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *HaltReasonChar_NEWSPEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_NEWSPEND));
  return pyobj;
}


SWIGINTERN int ExDestination_POSIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExDestination_POSIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExDestination_POSIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExDestination_POSIT));
  return pyobj;
}


SWIGINTERN int ExDestination_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExDestination_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExDestination_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExDestination_NONE));
  return pyobj;
}


SWIGINTERN int AllocReportType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 AllocReportType_WAREHOUSE_RECAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_WAREHOUSE_RECAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocReportType_WAREHOUSE_RECAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_WAREHOUSE_RECAP));
  return pyobj;
}


SWIGINTERN int AllocReportType_REJECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_REJECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocReportType_REJECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_REJECT));
  return pyobj;
}


SWIGINTERN int AllocReportType_REQUESTTOINTERMEDIARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_REQUESTTOINTERMEDIARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocReportType_REQUESTTOINTERMEDIARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_REQUESTTOINTERMEDIARY));
  return pyobj;
}


SWIGINTERN int AllocReportType_ACCEPT_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_ACCEPT_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocReportType_ACCEPT_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_ACCEPT_PENDING));
  return pyobj;
}


SWIGINTERN int AllocReportType_REQUEST_TO_INTERMEDIARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_REQUEST_TO_INTERMEDIARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 AllocReportType_COMPLETE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_COMPLETE is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocReportType_COMPLETE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_COMPLETE));
  return pyobj;
}


SWIGINTERN int AllocReportType_SELLSIDECALCULATEDUSINGPRELIMINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_SELLSIDECALCULATEDUSINGPRELIMINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocReportType_SELLSIDECALCULATEDUSINGPRELIMINARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_SELLSIDECALCULATEDUSINGPRELIMINARY));
  return pyobj;
}


SWIGINTERN int AllocReportType_PRELIMINARY_REQUEST_TO_INTERMEDIARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_PRELIMINARY_REQUEST_TO_INTERMEDIARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 AllocReportType_SELLSIDE_CALCULATED_USING_PRELIMINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_SELLSIDE_CALCULATED_USING_PRELIMINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 AllocReportType_REVERSE_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_REVERSE_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocReportType_REVERSE_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_REVERSE_PENDING));
  return pyobj;
}


SWIGINTERN int AllocReportType_WAREHOUSERECAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_WAREHOUSERECAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocReportType_WAREHOUSERECAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_WAREHOUSERECAP));
  return pyobj;
}


SWIGINTERN int AllocReportType_ACCEPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_ACCEPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocReportType_ACCEPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_ACCEPT));
  return pyobj;
}


SWIGINTERN int AllocReportType_SELLSIDECALCULATEDWITHOUTPRELIMINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_SELLSIDECALCULATEDWITHOUTPRELIMINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocReportType_SELLSIDECALCULATEDWITHOUTPRELIMINARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_SELLSIDECALCULATEDWITHOUTPRELIMINARY));
  return pyobj;
}


SWIGINTERN int AllocType_BUYSIDEREADYTOBOOKSINGLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_BUYSIDEREADYTOBOOKSINGLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocType_BUYSIDEREADYTOBOOKSINGLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_BUYSIDEREADYTOBOOKSINGLE));
  return pyobj;
}


SWIGINTERN int AllocType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 AllocType_CALCULATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_CALCULATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocType_CALCULATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_CALCULATED));
  return pyobj;
}


SWIGINTERN int AllocType_INCOMPLETE_GROUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_INCOMPLETE_GROUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocType_INCOMPLETE_GROUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_INCOMPLETE_GROUP));
  return pyobj;
}


SWIGINTERN int AllocType_REVERSAL_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_REVERSAL_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocType_REVERSAL_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_REVERSAL_PENDING));
  return pyobj;
}


SWIGINTERN int AllocType_PRELIMINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_PRELIMINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocType_PRELIMINARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_PRELIMINARY));
  return pyobj;
}


SWIGINTERN int AllocType_REJECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_REJECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocType_REJECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_REJECT));
  return pyobj;
}


SWIGINTERN int AllocType_WAREHOUSEINSTRUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_WAREHOUSEINSTRUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocType_WAREHOUSEINSTRUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_WAREHOUSEINSTRUCTION));
  return pyobj;
}


SWIGINTERN int AllocType_BUYSIDEPRELIM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_BUYSIDEPRELIM is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocType_BUYSIDEPRELIM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_BUYSIDEPRELIM));
  return pyobj;
}


SWIGINTERN int AllocType_REQUESTTOINTERMEDIARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_REQUESTTOINTERMEDIARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocType_REQUESTTOINTERMEDIARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_REQUESTTOINTERMEDIARY));
  return pyobj;
}


SWIGINTERN int AllocType_ACCEPT_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_ACCEPT_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocType_ACCEPT_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_ACCEPT_PENDING));
  return pyobj;
}


SWIGINTERN int AllocType_BUYSIDEREADYTOBOOKCOMBINED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_BUYSIDEREADYTOBOOKCOMBINED is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocType_BUYSIDEREADYTOBOOKCOMBINED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_BUYSIDEREADYTOBOOKCOMBINED));
  return pyobj;
}


SWIGINTERN int AllocType_BUYSIDE_CALCULATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_BUYSIDE_CALCULATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocType_BUYSIDE_CALCULATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_BUYSIDE_CALCULATED));
  return pyobj;
}


SWIGINTERN int AllocType_REQUEST_TO_INTERMEDIARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_REQUEST_TO_INTERMEDIARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 AllocType_SELLSIDECALCWITHOUTPRELIM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_SELLSIDECALCWITHOUTPRELIM is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocType_SELLSIDECALCWITHOUTPRELIM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_SELLSIDECALCWITHOUTPRELIM));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 AllocType_COMPLETE_GROUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_COMPLETE_GROUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocType_COMPLETE_GROUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_COMPLETE_GROUP));
  return pyobj;
}


SWIGINTERN int AllocType_BUYSIDECALC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_BUYSIDECALC is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocType_BUYSIDECALC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_BUYSIDECALC));
  return pyobj;
}


SWIGINTERN int AllocType_SELLSIDE_CALCULATED_USING_PRELIMINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_SELLSIDE_CALCULATED_USING_PRELIMINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 AllocType_READY_TO_BOOK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_READY_TO_BOOK is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 AllocType_BUYSIDE_READY_TO_BOOK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_BUYSIDE_READY_TO_BOOK is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 AllocType_WAREHOUSE_INSTRUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_WAREHOUSE_INSTRUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocType_WAREHOUSE_INSTRUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_WAREHOUSE_INSTRUCTION));
  return pyobj;
}


SWIGINTERN int AllocType_BUYSIDE_PRELIMINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_BUYSIDE_PRELIMINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocType_BUYSIDE_PRELIMINARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_BUYSIDE_PRELIMINARY));
  return pyobj;
}


SWIGINTERN int AllocType_ACCEPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_ACCEPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocType_ACCEPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_ACCEPT));
  return pyobj;
}


SWIGINTERN int AllocType_SELLSIDECALC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_SELLSIDECALC is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocType_SELLSIDECALC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_SELLSIDECALC));
  return pyobj;
}


SWIGINTERN int QuoteRequestRejectReason_INSUFFICIENT_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_INSUFFICIENT_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRequestRejectReason_INSUFFICIENT_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_INSUFFICIENT_CREDIT));
  return pyobj;
}


SWIGINTERN int QuoteRequestRejectReason_NOMARKETFORINSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_NOMARKETFORINSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRequestRejectReason_NOMARKETFORINSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_NOMARKETFORINSTRUMENT));
  return pyobj;
}


SWIGINTERN int QuoteRequestRejectReason_NOTAUTHTOREQQUOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_NOTAUTHTOREQQUOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRequestRejectReason_NOTAUTHTOREQQUOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_NOTAUTHTOREQQUOTE));
  return pyobj;
}


SWIGINTERN int 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 *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 QuoteRequestRejectReason_QUOTEREQUESTEXLIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_QUOTEREQUESTEXLIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRequestRejectReason_QUOTEREQUESTEXLIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_QUOTEREQUESTEXLIMIT));
  return pyobj;
}


SWIGINTERN int QuoteRequestRejectReason_INVALID_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_INVALID_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRequestRejectReason_INVALID_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_INVALID_PRICE));
  return pyobj;
}


SWIGINTERN int QuoteRequestRejectReason_EXCHANGECLOSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_EXCHANGECLOSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRequestRejectReason_EXCHANGECLOSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_EXCHANGECLOSED));
  return pyobj;
}


SWIGINTERN int QuoteRequestRejectReason_TOOLATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_TOOLATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRequestRejectReason_TOOLATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_TOOLATE));
  return pyobj;
}


SWIGINTERN int QuoteRequestRejectReason_INVPRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_INVPRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRequestRejectReason_INVPRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_INVPRICE));
  return pyobj;
}


SWIGINTERN int QuoteRequestRejectReason_NOMATCHFORINQUIRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_NOMATCHFORINQUIRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRequestRejectReason_NOMATCHFORINQUIRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_NOMATCHFORINQUIRY));
  return pyobj;
}


SWIGINTERN int QuoteRequestRejectReason_TOO_LATE_TO_ENTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_TOO_LATE_TO_ENTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 QuoteRequestRejectReason_NO_MATCH_FOR_INQUIRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_NO_MATCH_FOR_INQUIRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 QuoteRequestRejectReason_UNKNOWNSYM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_UNKNOWNSYM is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRequestRejectReason_UNKNOWNSYM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_UNKNOWNSYM));
  return pyobj;
}


SWIGINTERN int QuoteRequestRejectReason_EXCHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_EXCHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRequestRejectReason_EXCHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_EXCHANGE));
  return pyobj;
}


SWIGINTERN int QuoteRequestRejectReason_NO_MARKET_FOR_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_NO_MARKET_FOR_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 QuoteRequestRejectReason_UNKNOWN_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_UNKNOWN_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRequestRejectReason_UNKNOWN_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_UNKNOWN_SYMBOL));
  return pyobj;
}


SWIGINTERN int QuoteRequestRejectReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRequestRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_OTHER));
  return pyobj;
}


SWIGINTERN int QuoteRequestRejectReason_PASS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_PASS is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRequestRejectReason_PASS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_PASS));
  return pyobj;
}


SWIGINTERN int QuoteRequestRejectReason_NOINVENTORY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_NOINVENTORY is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRequestRejectReason_NOINVENTORY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_NOINVENTORY));
  return pyobj;
}


SWIGINTERN int QuoteRequestRejectReason_NO_INVENTORY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_NO_INVENTORY is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteRequestRejectReason_NO_INVENTORY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_NO_INVENTORY));
  return pyobj;
}


SWIGINTERN int QuoteRequestRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 LiquidityIndType_5DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LiquidityIndType_5DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *LiquidityIndType_5DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LiquidityIndType_5DAY));
  return pyobj;
}


SWIGINTERN int LiquidityIndType_NORMAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LiquidityIndType_NORMAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *LiquidityIndType_NORMAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LiquidityIndType_NORMAL));
  return pyobj;
}


SWIGINTERN int LiquidityIndType_20_DAY_MOVING_AVERAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LiquidityIndType_20_DAY_MOVING_AVERAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 LiquidityIndType_5_DAY_MOVING_AVERAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LiquidityIndType_5_DAY_MOVING_AVERAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 LiquidityIndType_5DAY_MOVING_AVERAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LiquidityIndType_5DAY_MOVING_AVERAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 LiquidityIndType_NORMAL_MARKET_SIZE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LiquidityIndType_NORMAL_MARKET_SIZE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 LiquidityIndType_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LiquidityIndType_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *LiquidityIndType_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LiquidityIndType_OTHER));
  return pyobj;
}


SWIGINTERN int LiquidityIndType_20DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LiquidityIndType_20DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *LiquidityIndType_20DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LiquidityIndType_20DAY));
  return pyobj;
}


SWIGINTERN int StatusValue_IN_PROCESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StatusValue_IN_PROCESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *StatusValue_IN_PROCESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StatusValue_IN_PROCESS));
  return pyobj;
}


SWIGINTERN int StatusValue_NOTCONNECTEDDOWNEXPECTEDUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StatusValue_NOTCONNECTEDDOWNEXPECTEDUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *StatusValue_NOTCONNECTEDDOWNEXPECTEDUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StatusValue_NOTCONNECTEDDOWNEXPECTEDUP));
  return pyobj;
}


SWIGINTERN int StatusValue_NOT_CONNECTED_2_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StatusValue_NOT_CONNECTED_2 is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 StatusValue_NOTCONNECTEDDOWNEXPECTEDDOWN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StatusValue_NOTCONNECTEDDOWNEXPECTEDDOWN is read-only.");
  return 1;
}


SWIGINTERN PyObject *StatusValue_NOTCONNECTEDDOWNEXPECTEDDOWN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StatusValue_NOTCONNECTEDDOWNEXPECTEDDOWN));
  return pyobj;
}


SWIGINTERN int StatusValue_CONNECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StatusValue_CONNECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *StatusValue_CONNECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StatusValue_CONNECTED));
  return pyobj;
}


SWIGINTERN int StatusValue_NOT_CONNECTED_3_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StatusValue_NOT_CONNECTED_3 is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 StatusValue_INPROCESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StatusValue_INPROCESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *StatusValue_INPROCESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StatusValue_INPROCESS));
  return pyobj;
}


SWIGINTERN int PosType_INTRA_SPREAD_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_INTRA_SPREAD_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_INTRA_SPREAD_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_INTRA_SPREAD_QTY);
  return pyobj;
}


SWIGINTERN int PosType_INTER_SPREAD_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_INTER_SPREAD_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_INTER_SPREAD_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_INTER_SPREAD_QTY);
  return pyobj;
}


SWIGINTERN int PosType_TRANSFER_TRADE_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_TRANSFER_TRADE_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_TRANSFER_TRADE_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_TRANSFER_TRADE_QTY);
  return pyobj;
}


SWIGINTERN int PosType_EXCHANGE_FOR_PHYSICAL_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_EXCHANGE_FOR_PHYSICAL_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_EXCHANGE_FOR_PHYSICAL_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_EXCHANGE_FOR_PHYSICAL_QTY);
  return pyobj;
}


SWIGINTERN int PosType_TRANSFERTRADEQTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_TRANSFERTRADEQTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_TRANSFERTRADEQTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_TRANSFERTRADEQTY);
  return pyobj;
}


SWIGINTERN int PosType_TRANSACTIONQUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_TRANSACTIONQUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_TRANSACTIONQUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_TRANSACTIONQUANTITY);
  return pyobj;
}


SWIGINTERN int PosType_ADJUSTMENTQTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_ADJUSTMENTQTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_ADJUSTMENTQTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_ADJUSTMENTQTY);
  return pyobj;
}


SWIGINTERN int PosType_START_OF_DAY_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_START_OF_DAY_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_START_OF_DAY_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_START_OF_DAY_QTY);
  return pyobj;
}


SWIGINTERN int PosType_ENDOFDAYQTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_ENDOFDAYQTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_ENDOFDAYQTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_ENDOFDAYQTY);
  return pyobj;
}


SWIGINTERN int PosType_DELIVERY_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_DELIVERY_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_DELIVERY_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_DELIVERY_QTY);
  return pyobj;
}


SWIGINTERN int PosType_TRANSACTIONFROMEXERCISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_TRANSACTIONFROMEXERCISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_TRANSACTIONFROMEXERCISE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_TRANSACTIONFROMEXERCISE);
  return pyobj;
}


SWIGINTERN int PosType_OPTIONEXERCISEQTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_OPTIONEXERCISEQTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_OPTIONEXERCISEQTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_OPTIONEXERCISEQTY);
  return pyobj;
}


SWIGINTERN int PosType_DELIVERYQTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_DELIVERYQTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_DELIVERYQTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_DELIVERYQTY);
  return pyobj;
}


SWIGINTERN int PosType_OPTION_ASSIGNMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_OPTION_ASSIGNMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_OPTION_ASSIGNMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_OPTION_ASSIGNMENT);
  return pyobj;
}


SWIGINTERN int PosType_PIT_TRADE_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_PIT_TRADE_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_PIT_TRADE_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_PIT_TRADE_QTY);
  return pyobj;
}


SWIGINTERN int PosType_TRANSACTION_FROM_ASSIGNMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_TRANSACTION_FROM_ASSIGNMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_TRANSACTION_FROM_ASSIGNMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_TRANSACTION_FROM_ASSIGNMENT);
  return pyobj;
}


SWIGINTERN int PosType_TRANSACTION_FROM_EXERCISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_TRANSACTION_FROM_EXERCISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_TRANSACTION_FROM_EXERCISE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_TRANSACTION_FROM_EXERCISE);
  return pyobj;
}


SWIGINTERN int PosType_INTEGRALSPLIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_INTEGRALSPLIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_INTEGRALSPLIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_INTEGRALSPLIT);
  return pyobj;
}


SWIGINTERN int PosType_ELECTRONICTRADEQTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_ELECTRONICTRADEQTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_ELECTRONICTRADEQTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_ELECTRONICTRADEQTY);
  return pyobj;
}


SWIGINTERN int PosType_AS_OF_TRADE_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_AS_OF_TRADE_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_AS_OF_TRADE_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_AS_OF_TRADE_QTY);
  return pyobj;
}


SWIGINTERN int PosType_ELECTRONIC_TRADE_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_ELECTRONIC_TRADE_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_ELECTRONIC_TRADE_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_ELECTRONIC_TRADE_QTY);
  return pyobj;
}


SWIGINTERN int PosType_PITTRADEQTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_PITTRADEQTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_PITTRADEQTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_PITTRADEQTY);
  return pyobj;
}


SWIGINTERN int PosType_OPTIONASSIGNMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_OPTIONASSIGNMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_OPTIONASSIGNMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_OPTIONASSIGNMENT);
  return pyobj;
}


SWIGINTERN int PosType_SUCCESSION_EVENT_ADJUSTMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_SUCCESSION_EVENT_ADJUSTMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_SUCCESSION_EVENT_ADJUSTMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_SUCCESSION_EVENT_ADJUSTMENT);
  return pyobj;
}


SWIGINTERN int PosType_OPTION_EXERCISE_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_OPTION_EXERCISE_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_OPTION_EXERCISE_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_OPTION_EXERCISE_QTY);
  return pyobj;
}


SWIGINTERN int PosType_TRANSACTION_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_TRANSACTION_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_TRANSACTION_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_TRANSACTION_QUANTITY);
  return pyobj;
}


SWIGINTERN int PosType_NET_DELTA_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_NET_DELTA_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_NET_DELTA_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_NET_DELTA_QTY);
  return pyobj;
}


SWIGINTERN int PosType_END_OF_DAY_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_END_OF_DAY_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_END_OF_DAY_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_END_OF_DAY_QTY);
  return pyobj;
}


SWIGINTERN int PosType_ADJUSTMENT_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_ADJUSTMENT_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_ADJUSTMENT_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_ADJUSTMENT_QTY);
  return pyobj;
}


SWIGINTERN int PosType_TOTAL_TRANSACTION_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_TOTAL_TRANSACTION_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_TOTAL_TRANSACTION_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_TOTAL_TRANSACTION_QTY);
  return pyobj;
}


SWIGINTERN int PosType_DELIVERY_NOTICE_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_DELIVERY_NOTICE_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_DELIVERY_NOTICE_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_DELIVERY_NOTICE_QTY);
  return pyobj;
}


SWIGINTERN int PosType_RECEIVE_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_RECEIVE_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_RECEIVE_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_RECEIVE_QUANTITY);
  return pyobj;
}


SWIGINTERN int PosType_ASOFTRADEQTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_ASOFTRADEQTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_ASOFTRADEQTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_ASOFTRADEQTY);
  return pyobj;
}


SWIGINTERN int PosType_ALLOCATIONTRADEQTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_ALLOCATIONTRADEQTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_ALLOCATIONTRADEQTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_ALLOCATIONTRADEQTY);
  return pyobj;
}


SWIGINTERN int PosType_CREDIT_EVENT_ADJUSTMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_CREDIT_EVENT_ADJUSTMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_CREDIT_EVENT_ADJUSTMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_CREDIT_EVENT_ADJUSTMENT);
  return pyobj;
}


SWIGINTERN int PosType_PRIVATELY_NEGOTIATED_TRADE_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_PRIVATELY_NEGOTIATED_TRADE_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_PRIVATELY_NEGOTIATED_TRADE_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_PRIVATELY_NEGOTIATED_TRADE_QTY);
  return pyobj;
}


SWIGINTERN int PosType_CROSS_MARGIN_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_CROSS_MARGIN_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_CROSS_MARGIN_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_CROSS_MARGIN_QTY);
  return pyobj;
}


SWIGINTERN int PosType_CORPORATE_ACTION_ADJUSTMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_CORPORATE_ACTION_ADJUSTMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_CORPORATE_ACTION_ADJUSTMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_CORPORATE_ACTION_ADJUSTMENT);
  return pyobj;
}


SWIGINTERN int PosType_TOTALTRANSACTIONQTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_TOTALTRANSACTIONQTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_TOTALTRANSACTIONQTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_TOTALTRANSACTIONQTY);
  return pyobj;
}


SWIGINTERN int PosType_STARTOFDAYQTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_STARTOFDAYQTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_STARTOFDAYQTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_STARTOFDAYQTY);
  return pyobj;
}


SWIGINTERN int PosType_INTEGRAL_SPLIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_INTEGRAL_SPLIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_INTEGRAL_SPLIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_INTEGRAL_SPLIT);
  return pyobj;
}


SWIGINTERN int PosType_INTERSPREADQTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_INTERSPREADQTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_INTERSPREADQTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_INTERSPREADQTY);
  return pyobj;
}


SWIGINTERN int PosType_INTRASPREADQTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_INTRASPREADQTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_INTRASPREADQTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_INTRASPREADQTY);
  return pyobj;
}


SWIGINTERN int PosType_ALLOCATION_TRADE_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_ALLOCATION_TRADE_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_ALLOCATION_TRADE_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_ALLOCATION_TRADE_QTY);
  return pyobj;
}


SWIGINTERN int PosType_CROSSMARGINQTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_CROSSMARGINQTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_CROSSMARGINQTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_CROSSMARGINQTY);
  return pyobj;
}


SWIGINTERN int PosType_TRANSACTIONFROMASSIGNMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_TRANSACTIONFROMASSIGNMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosType_TRANSACTIONFROMASSIGNMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_TRANSACTIONFROMASSIGNMENT);
  return pyobj;
}


SWIGINTERN int StreamAsgnAckType_ASSIGNMENT_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnAckType_ASSIGNMENT_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *StreamAsgnAckType_ASSIGNMENT_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamAsgnAckType_ASSIGNMENT_REJECTED));
  return pyobj;
}


SWIGINTERN int StreamAsgnAckType_ASSIGNMENT_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnAckType_ASSIGNMENT_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *StreamAsgnAckType_ASSIGNMENT_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamAsgnAckType_ASSIGNMENT_ACCEPTED));
  return pyobj;
}


SWIGINTERN int RiskInstrumentOperator_EXCLUDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskInstrumentOperator_EXCLUDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *RiskInstrumentOperator_EXCLUDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskInstrumentOperator_EXCLUDE));
  return pyobj;
}


SWIGINTERN int RiskInstrumentOperator_INCLUDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RiskInstrumentOperator_INCLUDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *RiskInstrumentOperator_INCLUDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RiskInstrumentOperator_INCLUDE));
  return pyobj;
}


SWIGINTERN int MiscFeeBasis_PERUNIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeBasis_PERUNIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *MiscFeeBasis_PERUNIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MiscFeeBasis_PERUNIT));
  return pyobj;
}


SWIGINTERN int MiscFeeBasis_ABSOLUTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeBasis_ABSOLUTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MiscFeeBasis_ABSOLUTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MiscFeeBasis_ABSOLUTE));
  return pyobj;
}


SWIGINTERN int MiscFeeBasis_PERCENTAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeBasis_PERCENTAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MiscFeeBasis_PERCENTAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MiscFeeBasis_PERCENTAGE));
  return pyobj;
}


SWIGINTERN int MiscFeeBasis_PER_UNIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeBasis_PER_UNIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *MiscFeeBasis_PER_UNIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MiscFeeBasis_PER_UNIT));
  return pyobj;
}


SWIGINTERN int OrdType_FOREX_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_FOREX_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_FOREX_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_MARKET));
  return pyobj;
}


SWIGINTERN int OrdType_FOREX_PREVIOUSLY_QUOTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_FOREX_PREVIOUSLY_QUOTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 OrdType_ONBASIS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_ONBASIS is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_ONBASIS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_ONBASIS));
  return pyobj;
}


SWIGINTERN int OrdType_PREVIOUSLYINDICATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_PREVIOUSLYINDICATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_PREVIOUSLYINDICATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_PREVIOUSLYINDICATED));
  return pyobj;
}


SWIGINTERN int OrdType_PREVIOUS_FUND_VALUATION_POINT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_PREVIOUS_FUND_VALUATION_POINT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 OrdType_PEGGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_PEGGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_PEGGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_PEGGED));
  return pyobj;
}


SWIGINTERN int OrdType_LIMITONCLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_LIMITONCLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_LIMITONCLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_LIMITONCLOSE));
  return pyobj;
}


SWIGINTERN int OrdType_LIMIT_WITH_OR_WITHOUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_LIMIT_WITH_OR_WITHOUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 OrdType_STOP_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_STOP_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_STOP_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_STOP_LIMIT));
  return pyobj;
}


SWIGINTERN int OrdType_FOREX_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_FOREX_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_FOREX_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_SWAP));
  return pyobj;
}


SWIGINTERN int OrdType_WITHORWITHOUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_WITHORWITHOUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_WITHORWITHOUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_WITHORWITHOUT));
  return pyobj;
}


SWIGINTERN int OrdType_FOREXLIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_FOREXLIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_FOREXLIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREXLIMIT));
  return pyobj;
}


SWIGINTERN int 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 *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 OrdType_PREVIOUSLYQUOTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_PREVIOUSLYQUOTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_PREVIOUSLYQUOTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_PREVIOUSLYQUOTED));
  return pyobj;
}


SWIGINTERN int OrdType_PREVIOUSLY_QUOTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_PREVIOUSLY_QUOTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_PREVIOUSLY_QUOTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_PREVIOUSLY_QUOTED));
  return pyobj;
}


SWIGINTERN int OrdType_COUNTER_ORDER_SELECTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_COUNTER_ORDER_SELECTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 OrdType_LIMITWITHORWITHOUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_LIMITWITHORWITHOUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_LIMITWITHORWITHOUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_LIMITWITHORWITHOUT));
  return pyobj;
}


SWIGINTERN int OrdType_FOREXSWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_FOREXSWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_FOREXSWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREXSWAP));
  return pyobj;
}


SWIGINTERN int OrdType_MARKET_IF_TOUCHED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_MARKET_IF_TOUCHED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 OrdType_NEXT_FUND_VALUATION_POINT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_NEXT_FUND_VALUATION_POINT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 OrdType_FOREX_C_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_FOREX_C is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_FOREX_C_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_C));
  return pyobj;
}


SWIGINTERN int OrdType_ON_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_ON_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_ON_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_ON_CLOSE));
  return pyobj;
}


SWIGINTERN int OrdType_STOP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_STOP is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_STOP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_STOP));
  return pyobj;
}


SWIGINTERN int OrdType_STOPLIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_STOPLIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_STOPLIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_STOPLIMIT));
  return pyobj;
}


SWIGINTERN int OrdType_LIMITORBETTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_LIMITORBETTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_LIMITORBETTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_LIMITORBETTER));
  return pyobj;
}


SWIGINTERN int OrdType_ONCLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_ONCLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_ONCLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_ONCLOSE));
  return pyobj;
}


SWIGINTERN int OrdType_FOREX_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_FOREX_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_FOREX_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_LIMIT));
  return pyobj;
}


SWIGINTERN int OrdType_FOREXMARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_FOREXMARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_FOREXMARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREXMARKET));
  return pyobj;
}


SWIGINTERN int OrdType_FOREX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_FOREX is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_FOREX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX));
  return pyobj;
}


SWIGINTERN int OrdType_MARKETIFTOUCHED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_MARKETIFTOUCHED is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_MARKETIFTOUCHED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_MARKETIFTOUCHED));
  return pyobj;
}


SWIGINTERN int OrdType_FUNARI_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_FUNARI is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_FUNARI_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_FUNARI));
  return pyobj;
}


SWIGINTERN int OrdType_FOREX_F_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_FOREX_F is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_FOREX_F_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_F));
  return pyobj;
}


SWIGINTERN int OrdType_PREVIOUSLY_INDICATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_PREVIOUSLY_INDICATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_PREVIOUSLY_INDICATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_PREVIOUSLY_INDICATED));
  return pyobj;
}


SWIGINTERN int OrdType_WITH_OR_WITHOUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_WITH_OR_WITHOUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 OrdType_MARKET_ON_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_MARKET_ON_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 OrdType_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_LIMIT));
  return pyobj;
}


SWIGINTERN int 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 *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 OrdType_FOREX_G_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_FOREX_G is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_FOREX_G_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_G));
  return pyobj;
}


SWIGINTERN int OrdType_LIMIT_ON_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_LIMIT_ON_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 OrdType_MARKETONCLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_MARKETONCLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_MARKETONCLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_MARKETONCLOSE));
  return pyobj;
}


SWIGINTERN int OrdType_PREVIOUSFUNDVALUATIONPOINT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_PREVIOUSFUNDVALUATIONPOINT is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_PREVIOUSFUNDVALUATIONPOINT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_PREVIOUSFUNDVALUATIONPOINT));
  return pyobj;
}


SWIGINTERN int OrdType_NEXTFUNDVALUATIONPOINT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_NEXTFUNDVALUATIONPOINT is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_NEXTFUNDVALUATIONPOINT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_NEXTFUNDVALUATIONPOINT));
  return pyobj;
}


SWIGINTERN int OrdType_FOREX_H_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_FOREX_H is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_FOREX_H_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_H));
  return pyobj;
}


SWIGINTERN int OrdType_FOREXPREVIOUSLYQUOTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_FOREXPREVIOUSLYQUOTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_FOREXPREVIOUSLYQUOTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREXPREVIOUSLYQUOTED));
  return pyobj;
}


SWIGINTERN int OrdType_MARKETWITHLEFTOVERLIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_MARKETWITHLEFTOVERLIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_MARKETWITHLEFTOVERLIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_MARKETWITHLEFTOVERLIMIT));
  return pyobj;
}


SWIGINTERN int OrdType_ON_BASIS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_ON_BASIS is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_ON_BASIS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_ON_BASIS));
  return pyobj;
}


SWIGINTERN int OrdType_LIMIT_OR_BETTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_LIMIT_OR_BETTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 OrdType_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *OrdType_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_MARKET));
  return pyobj;
}


SWIGINTERN int MatchType_ACT_DEFAULT_AFTER_M2_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_ACT_DEFAULT_AFTER_M2 is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_ACT_DEFAULT_AFTER_M2_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_ACT_DEFAULT_AFTER_M2);
  return pyobj;
}


SWIGINTERN int MatchType_SUMMARIZEDMATCHUSINGA2_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_SUMMARIZEDMATCHUSINGA2 is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_SUMMARIZEDMATCHUSINGA2_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZEDMATCHUSINGA2);
  return pyobj;
}


SWIGINTERN int MatchType_COUNTER_ORDER_SELECTION_6_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_COUNTER_ORDER_SELECTION_6 is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_COUNTER_ORDER_SELECTION_6_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_COUNTER_ORDER_SELECTION_6);
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 MatchType_NON_ACT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_NON_ACT is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_NON_ACT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_NON_ACT);
  return pyobj;
}


SWIGINTERN int MatchType_SUMMARIZEDMATCHUSINGA3_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_SUMMARIZEDMATCHUSINGA3 is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_SUMMARIZEDMATCHUSINGA3_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZEDMATCHUSINGA3);
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 MatchType_SUMMARIZEDMATCHUSINGA4_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_SUMMARIZEDMATCHUSINGA4 is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_SUMMARIZEDMATCHUSINGA4_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZEDMATCHUSINGA4);
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 MatchType_SUMMARIZEDMATCHUSINGA5_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_SUMMARIZEDMATCHUSINGA5 is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_SUMMARIZEDMATCHUSINGA5_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZEDMATCHUSINGA5);
  return pyobj;
}


SWIGINTERN int MatchType_NASDAQACTM2MATCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_NASDAQACTM2MATCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_NASDAQACTM2MATCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_NASDAQACTM2MATCH);
  return pyobj;
}


SWIGINTERN int MatchType_CROSS_AUCTION_5_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_CROSS_AUCTION_5 is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_CROSS_AUCTION_5_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_CROSS_AUCTION_5);
  return pyobj;
}


SWIGINTERN int MatchType_ACT_M1_MATCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_ACT_M1_MATCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_ACT_M1_MATCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_ACT_M1_MATCH);
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSTWOBADGES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSTWOBADGES is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSTWOBADGES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSTWOBADGES);
  return pyobj;
}


SWIGINTERN int MatchType_NASDAQACTDEFAULTAFTERM2_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_NASDAQACTDEFAULTAFTERM2 is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_NASDAQACTDEFAULTAFTERM2_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_NASDAQACTDEFAULTAFTERM2);
  return pyobj;
}


SWIGINTERN int MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSFOURBADGES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSFOURBADGES is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSFOURBADGES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSFOURBADGES);
  return pyobj;
}


SWIGINTERN int MatchType_NASDAQACTM1MATCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_NASDAQACTM1MATCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_NASDAQACTM1MATCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_NASDAQACTM1MATCH);
  return pyobj;
}


SWIGINTERN int MatchType_CALL_AUCTION_7_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_CALL_AUCTION_7 is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_CALL_AUCTION_7_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_CALL_AUCTION_7);
  return pyobj;
}


SWIGINTERN int MatchType_CROSS_AUCTION_63_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_CROSS_AUCTION_63 is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_CROSS_AUCTION_63_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_CROSS_AUCTION_63);
  return pyobj;
}


SWIGINTERN int MatchType_ISSUING_BUY_BACK_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_ISSUING_BUY_BACK_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_ISSUING_BUY_BACK_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_ISSUING_BUY_BACK_AUCTION);
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSFOURBADGESANDEXECUTIONTIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSFOURBADGESANDEXECUTIONTIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSFOURBADGESANDEXECUTIONTIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSFOURBADGESANDEXECUTIONTIME);
  return pyobj;
}


SWIGINTERN int MatchType_ONE_PARTY_TRADE_REPORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_ONE_PARTY_TRADE_REPORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_ONE_PARTY_TRADE_REPORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_ONE_PARTY_TRADE_REPORT);
  return pyobj;
}


SWIGINTERN int 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 *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 MatchType_ACT_M2_MATCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_ACT_M2_MATCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_ACT_M2_MATCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_ACT_M2_MATCH);
  return pyobj;
}


SWIGINTERN int MatchType_SUMMARIZEDMATCHMINUSBADGESANDTIMES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_SUMMARIZEDMATCHMINUSBADGESANDTIMES is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_SUMMARIZEDMATCHMINUSBADGESANDTIMES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZEDMATCHMINUSBADGESANDTIMES);
  return pyobj;
}


SWIGINTERN int MatchType_NASDAQACTDEFAULTTRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_NASDAQACTDEFAULTTRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_NASDAQACTDEFAULTTRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_NASDAQACTDEFAULTTRADE);
  return pyobj;
}


SWIGINTERN int MatchType_CALL_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_CALL_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_CALL_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_CALL_AUCTION);
  return pyobj;
}


SWIGINTERN int 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 *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 MatchType_ACT_ACCEPTED_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_ACT_ACCEPTED_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_ACT_ACCEPTED_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_ACT_ACCEPTED_TRADE);
  return pyobj;
}


SWIGINTERN int MatchType_TWO_PARTY_TRADE_REPORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_TWO_PARTY_TRADE_REPORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_TWO_PARTY_TRADE_REPORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_TWO_PARTY_TRADE_REPORT);
  return pyobj;
}


SWIGINTERN int 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 *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 MatchType_CONTINUOUS_AUTO_MATCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_CONTINUOUS_AUTO_MATCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_CONTINUOUS_AUTO_MATCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_CONTINUOUS_AUTO_MATCH);
  return pyobj;
}


SWIGINTERN int 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 *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 MatchType_ACT_M6_MATCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_ACT_M6_MATCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_ACT_M6_MATCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_ACT_M6_MATCH);
  return pyobj;
}


SWIGINTERN int 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 *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 MatchType_ACT_DEFAULT_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_ACT_DEFAULT_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_ACT_DEFAULT_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_ACT_DEFAULT_TRADE);
  return pyobj;
}


SWIGINTERN int MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORMINUSBADGESANDTIMES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORMINUSBADGESANDTIMES is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORMINUSBADGESANDTIMES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORMINUSBADGESANDTIMES);
  return pyobj;
}


SWIGINTERN int 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 *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 MatchType_AUTO_MATCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_AUTO_MATCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_AUTO_MATCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_AUTO_MATCH);
  return pyobj;
}


SWIGINTERN int MatchType_NASDAQACTM6MATCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_NASDAQACTM6MATCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_NASDAQACTM6MATCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_NASDAQACTM6MATCH);
  return pyobj;
}


SWIGINTERN int MatchType_OCSLOCKEDIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_OCSLOCKEDIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_OCSLOCKEDIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_OCSLOCKEDIN);
  return pyobj;
}


SWIGINTERN int MatchType_COUNTER_ORDER_SELECTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_COUNTER_ORDER_SELECTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_COUNTER_ORDER_SELECTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_COUNTER_ORDER_SELECTION);
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 MatchType_NASDAQACTACCEPTEDTRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_NASDAQACTACCEPTEDTRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_NASDAQACTACCEPTEDTRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_NASDAQACTACCEPTEDTRADE);
  return pyobj;
}


SWIGINTERN int MatchType_CALL_AUCTION_65_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_CALL_AUCTION_65 is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_CALL_AUCTION_65_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_CALL_AUCTION_65);
  return pyobj;
}


SWIGINTERN int MatchType_CROSS_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_CROSS_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_CROSS_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_CROSS_AUCTION);
  return pyobj;
}


SWIGINTERN int 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 *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 MatchType_CONFIRMED_TRADE_REPORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_CONFIRMED_TRADE_REPORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_CONFIRMED_TRADE_REPORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_CONFIRMED_TRADE_REPORT);
  return pyobj;
}


SWIGINTERN int 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 *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 MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSTWOBADGESANDEXECUTIONTIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSTWOBADGESANDEXECUTIONTIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSTWOBADGESANDEXECUTIONTIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSTWOBADGESANDEXECUTIONTIME);
  return pyobj;
}


SWIGINTERN int 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 *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 MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSEXECUTIONTIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSEXECUTIONTIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSEXECUTIONTIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSEXECUTIONTIME);
  return pyobj;
}


SWIGINTERN int MatchType_NASDAQNONACT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_NASDAQNONACT is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_NASDAQNONACT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_NASDAQNONACT);
  return pyobj;
}


SWIGINTERN int MatchType_COMPAREDRECORDSRESULTINGFROMSTAMPEDADVISORIESORSPECIALISTACCEPTSPAIROFFS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_COMPAREDRECORDSRESULTINGFROMSTAMPEDADVISORIESORSPECIALISTACCEPTSPAIROFFS is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_COMPAREDRECORDSRESULTINGFROMSTAMPEDADVISORIESORSPECIALISTACCEPTSPAIROFFS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_COMPAREDRECORDSRESULTINGFROMSTAMPEDADVISORIESORSPECIALISTACCEPTSPAIROFFS);
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 MatchType_SUMMARIZEDMATCHUSINGA1_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_SUMMARIZEDMATCHUSINGA1 is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_SUMMARIZEDMATCHUSINGA1_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZEDMATCHUSINGA1);
  return pyobj;
}


SWIGINTERN int 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 *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 MatchType_COUNTER_ORDER_SELECTION_64_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_COUNTER_ORDER_SELECTION_64 is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchType_COUNTER_ORDER_SELECTION_64_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_COUNTER_ORDER_SELECTION_64);
  return pyobj;
}


SWIGINTERN int OptPayoutType_BINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OptPayoutType_BINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *OptPayoutType_BINARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OptPayoutType_BINARY));
  return pyobj;
}


SWIGINTERN int OptPayoutType_VANILLA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OptPayoutType_VANILLA is read-only.");
  return 1;
}


SWIGINTERN PyObject *OptPayoutType_VANILLA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OptPayoutType_VANILLA));
  return pyobj;
}


SWIGINTERN int OptPayoutType_CAPPED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OptPayoutType_CAPPED is read-only.");
  return 1;
}


SWIGINTERN PyObject *OptPayoutType_CAPPED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OptPayoutType_CAPPED));
  return pyobj;
}


SWIGINTERN int MarketUpdateAction_DELETE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketUpdateAction_DELETE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MarketUpdateAction_DELETE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MarketUpdateAction_DELETE));
  return pyobj;
}


SWIGINTERN int MarketUpdateAction_ADD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketUpdateAction_ADD is read-only.");
  return 1;
}


SWIGINTERN PyObject *MarketUpdateAction_ADD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MarketUpdateAction_ADD));
  return pyobj;
}


SWIGINTERN int MarketUpdateAction_MODIFY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketUpdateAction_MODIFY is read-only.");
  return 1;
}


SWIGINTERN PyObject *MarketUpdateAction_MODIFY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MarketUpdateAction_MODIFY));
  return pyobj;
}


SWIGINTERN int CollAsgnRejectReason_INVALIDTYPEOFCOLLATERAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRejectReason_INVALIDTYPEOFCOLLATERAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollAsgnRejectReason_INVALIDTYPEOFCOLLATERAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_INVALIDTYPEOFCOLLATERAL));
  return pyobj;
}


SWIGINTERN int CollAsgnRejectReason_UNAUTHORIZED_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRejectReason_UNAUTHORIZED_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollAsgnRejectReason_UNAUTHORIZED_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_UNAUTHORIZED_TRANSACTION));
  return pyobj;
}


SWIGINTERN int CollAsgnRejectReason_UNKNOWN_OR_INVALID_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRejectReason_UNKNOWN_OR_INVALID_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 CollAsgnRejectReason_UNKNOWNDEAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRejectReason_UNKNOWNDEAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollAsgnRejectReason_UNKNOWNDEAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_UNKNOWNDEAL));
  return pyobj;
}


SWIGINTERN int CollAsgnRejectReason_UNKNOWN_DEAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRejectReason_UNKNOWN_DEAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollAsgnRejectReason_UNKNOWN_DEAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_UNKNOWN_DEAL));
  return pyobj;
}


SWIGINTERN int CollAsgnRejectReason_UNAUTHORIZEDTRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRejectReason_UNAUTHORIZEDTRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollAsgnRejectReason_UNAUTHORIZEDTRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_UNAUTHORIZEDTRANSACTION));
  return pyobj;
}


SWIGINTERN int CollAsgnRejectReason_INVALID_TYPE_OF_COLLATERAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRejectReason_INVALID_TYPE_OF_COLLATERAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 CollAsgnRejectReason_INSUFFICIENTCOLLATERAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRejectReason_INSUFFICIENTCOLLATERAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollAsgnRejectReason_INSUFFICIENTCOLLATERAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_INSUFFICIENTCOLLATERAL));
  return pyobj;
}


SWIGINTERN int CollAsgnRejectReason_UNKNOWNORINVALIDINSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRejectReason_UNKNOWNORINVALIDINSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollAsgnRejectReason_UNKNOWNORINVALIDINSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_UNKNOWNORINVALIDINSTRUMENT));
  return pyobj;
}


SWIGINTERN int CollAsgnRejectReason_EXCESSIVE_SUBSTITUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRejectReason_EXCESSIVE_SUBSTITUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollAsgnRejectReason_EXCESSIVE_SUBSTITUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_EXCESSIVE_SUBSTITUTION));
  return pyobj;
}


SWIGINTERN int CollAsgnRejectReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRejectReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollAsgnRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_OTHER));
  return pyobj;
}


SWIGINTERN int CollAsgnRejectReason_INSUFFICIENT_COLLATERAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRejectReason_INSUFFICIENT_COLLATERAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollAsgnRejectReason_INSUFFICIENT_COLLATERAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_INSUFFICIENT_COLLATERAL));
  return pyobj;
}


SWIGINTERN int CollAsgnRejectReason_EXCESSIVESUBSTITUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRejectReason_EXCESSIVESUBSTITUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollAsgnRejectReason_EXCESSIVESUBSTITUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_EXCESSIVESUBSTITUTION));
  return pyobj;
}


SWIGINTERN int IndividualAllocType_SUB_ALLOCATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IndividualAllocType_SUB_ALLOCATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *IndividualAllocType_SUB_ALLOCATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::IndividualAllocType_SUB_ALLOCATE));
  return pyobj;
}


SWIGINTERN int IndividualAllocType_THIRD_PARTY_ALLOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IndividualAllocType_THIRD_PARTY_ALLOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 GTBookingInst_ACCUMUNTILFILL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable GTBookingInst_ACCUMUNTILFILL is read-only.");
  return 1;
}


SWIGINTERN PyObject *GTBookingInst_ACCUMUNTILFILL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::GTBookingInst_ACCUMUNTILFILL));
  return pyobj;
}


SWIGINTERN int GTBookingInst_ACCUMUNTILNOTIFY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable GTBookingInst_ACCUMUNTILNOTIFY is read-only.");
  return 1;
}


SWIGINTERN PyObject *GTBookingInst_ACCUMUNTILNOTIFY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::GTBookingInst_ACCUMUNTILNOTIFY));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 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 *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 GTBookingInst_BOOKALL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable GTBookingInst_BOOKALL is read-only.");
  return 1;
}


SWIGINTERN PyObject *GTBookingInst_BOOKALL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::GTBookingInst_BOOKALL));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 PutOrCall_PUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PutOrCall_PUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *PutOrCall_PUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PutOrCall_PUT));
  return pyobj;
}


SWIGINTERN int PutOrCall_CALL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PutOrCall_CALL is read-only.");
  return 1;
}


SWIGINTERN PyObject *PutOrCall_CALL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PutOrCall_CALL));
  return pyobj;
}


SWIGINTERN int FundRenewWaiv_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FundRenewWaiv_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *FundRenewWaiv_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::FundRenewWaiv_NO));
  return pyobj;
}


SWIGINTERN int FundRenewWaiv_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FundRenewWaiv_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *FundRenewWaiv_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::FundRenewWaiv_YES));
  return pyobj;
}


SWIGINTERN int ForexReq_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ForexReq_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *ForexReq_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ForexReq_NO));
  return pyobj;
}


SWIGINTERN int ForexReq_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ForexReq_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *ForexReq_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ForexReq_YES));
  return pyobj;
}


SWIGINTERN int 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 *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 TickRuleType_REGULAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickRuleType_REGULAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *TickRuleType_REGULAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TickRuleType_REGULAR));
  return pyobj;
}


SWIGINTERN int TickRuleType_VARIABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickRuleType_VARIABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TickRuleType_VARIABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TickRuleType_VARIABLE));
  return pyobj;
}


SWIGINTERN int 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 *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 TickRuleType_FIXED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickRuleType_FIXED is read-only.");
  return 1;
}


SWIGINTERN PyObject *TickRuleType_FIXED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TickRuleType_FIXED));
  return pyobj;
}


SWIGINTERN int DiscretionOffsetType_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionOffsetType_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *DiscretionOffsetType_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionOffsetType_PRICE));
  return pyobj;
}


SWIGINTERN int DiscretionOffsetType_BASISPOINTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionOffsetType_BASISPOINTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *DiscretionOffsetType_BASISPOINTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionOffsetType_BASISPOINTS));
  return pyobj;
}


SWIGINTERN int DiscretionOffsetType_PRICE_TIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionOffsetType_PRICE_TIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *DiscretionOffsetType_PRICE_TIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionOffsetType_PRICE_TIER));
  return pyobj;
}


SWIGINTERN int DiscretionOffsetType_TICKS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionOffsetType_TICKS is read-only.");
  return 1;
}


SWIGINTERN PyObject *DiscretionOffsetType_TICKS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionOffsetType_TICKS));
  return pyobj;
}


SWIGINTERN int DiscretionOffsetType_PRICETIERLEVEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionOffsetType_PRICETIERLEVEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *DiscretionOffsetType_PRICETIERLEVEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionOffsetType_PRICETIERLEVEL));
  return pyobj;
}


SWIGINTERN int DiscretionOffsetType_BASIS_POINTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionOffsetType_BASIS_POINTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *DiscretionOffsetType_BASIS_POINTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionOffsetType_BASIS_POINTS));
  return pyobj;
}


SWIGINTERN int ConfirmTransType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmTransType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ConfirmTransType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmTransType_REPLACE));
  return pyobj;
}


SWIGINTERN int ConfirmTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *ConfirmTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmTransType_NEW));
  return pyobj;
}


SWIGINTERN int ConfirmTransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmTransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *ConfirmTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmTransType_CANCEL));
  return pyobj;
}


SWIGINTERN int MDSecSizeType_CUSTOMER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDSecSizeType_CUSTOMER is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDSecSizeType_CUSTOMER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDSecSizeType_CUSTOMER));
  return pyobj;
}


SWIGINTERN int TradSesEvent_CHANGE_OF_TRADING_STATUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesEvent_CHANGE_OF_TRADING_STATUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TradSesEvent_CHANGE_OF_TRADING_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesEvent_CHANGE_OF_TRADING_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TradSesEvent_CHANGE_OF_TRADING_SUBSESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesEvent_CHANGE_OF_TRADING_SUBSESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TradSesEvent_TRADING_RESUMES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesEvent_TRADING_RESUMES is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradSesEvent_TRADING_RESUMES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesEvent_TRADING_RESUMES));
  return pyobj;
}


SWIGINTERN int DlvyInstType_SECURITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DlvyInstType_SECURITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *DlvyInstType_SECURITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DlvyInstType_SECURITIES));
  return pyobj;
}


SWIGINTERN int DlvyInstType_CASH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DlvyInstType_CASH is read-only.");
  return 1;
}


SWIGINTERN PyObject *DlvyInstType_CASH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DlvyInstType_CASH));
  return pyobj;
}


SWIGINTERN int TradeCondition_IMPLIED_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_IMPLIED_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_IMPLIED_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_IMPLIED_TRADE);
  return pyobj;
}


SWIGINTERN int TradeCondition_CASHMKT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CASHMKT is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_CASHMKT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CASHMKT);
  return pyobj;
}


SWIGINTERN int TradeCondition_OPENING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_OPENING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_OPENING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_OPENING_PRICE);
  return pyobj;
}


SWIGINTERN int TradeCondition_PRIOR_REFERENCE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_PRIOR_REFERENCE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_PRIOR_REFERENCE_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_PRIOR_REFERENCE_PRICE);
  return pyobj;
}


SWIGINTERN int TradeCondition_CANCEL_LAST_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CANCEL_LAST_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_CANCEL_LAST_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_LAST_ETH);
  return pyobj;
}


SWIGINTERN int TradeCondition_SELLER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_SELLER is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_SELLER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_SELLER);
  return pyobj;
}


SWIGINTERN int TradeCondition_DISTRIBUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_DISTRIBUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_DISTRIBUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_DISTRIBUTION);
  return pyobj;
}


SWIGINTERN int TradeCondition_NEXT_DAY_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_NEXT_DAY_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_NEXT_DAY_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_NEXT_DAY_TRADE);
  return pyobj;
}


SWIGINTERN int TradeCondition_STRADDLE_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_STRADDLE_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_STRADDLE_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_STRADDLE_ETH);
  return pyobj;
}


SWIGINTERN int TradeCondition_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_SPREAD);
  return pyobj;
}


SWIGINTERN int TradeCondition_OPENINGPRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_OPENINGPRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_OPENINGPRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_OPENINGPRICE);
  return pyobj;
}


SWIGINTERN int TradeCondition_CROSSED_AO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CROSSED_AO is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_CROSSED_AO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CROSSED_AO);
  return pyobj;
}


SWIGINTERN int TradeCondition_SOLD_LAST_SALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_SOLD_LAST_SALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_SOLD_LAST_SALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_SOLD_LAST_SALE);
  return pyobj;
}


SWIGINTERN int TradeCondition_OPENED_SALE_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_OPENED_SALE_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_OPENED_SALE_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_OPENED_SALE_ETH);
  return pyobj;
}


SWIGINTERN int TradeCondition_REOPEN_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_REOPEN_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_REOPEN_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_REOPEN_ETH);
  return pyobj;
}


SWIGINTERN int TradeCondition_SOLD_LAST_SALE_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_SOLD_LAST_SALE_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_SOLD_LAST_SALE_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_SOLD_LAST_SALE_ETH);
  return pyobj;
}


SWIGINTERN int TradeCondition_STOPPED_SOLD_LAST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_STOPPED_SOLD_LAST is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_STOPPED_SOLD_LAST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_STOPPED_SOLD_LAST);
  return pyobj;
}


SWIGINTERN int 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 *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 TradeCondition_NEXTDAY_D_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_NEXTDAY_D is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_NEXTDAY_D_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_NEXTDAY_D);
  return pyobj;
}


SWIGINTERN int TradeCondition_FORM_T_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_FORM_T is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_FORM_T_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_FORM_T);
  return pyobj;
}


SWIGINTERN int TradeCondition_ADJUSTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_ADJUSTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_ADJUSTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_ADJUSTED);
  return pyobj;
}


SWIGINTERN int TradeCondition_CANCEL_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CANCEL_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_CANCEL_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_ETH);
  return pyobj;
}


SWIGINTERN int TradeCondition_OUT_OF_SEQUENCE_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_OUT_OF_SEQUENCE_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_OUT_OF_SEQUENCE_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_OUT_OF_SEQUENCE_ETH);
  return pyobj;
}


SWIGINTERN int TradeCondition_RULE127_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_RULE127 is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_RULE127_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_RULE127);
  return pyobj;
}


SWIGINTERN int TradeCondition_COMBO_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_COMBO_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_COMBO_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_COMBO_ETH);
  return pyobj;
}


SWIGINTERN int TradeCondition_CANCEL_ONLY_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CANCEL_ONLY_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_CANCEL_ONLY_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_ONLY_ETH);
  return pyobj;
}


SWIGINTERN int TradeCondition_STRADDLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_STRADDLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_STRADDLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_STRADDLE);
  return pyobj;
}


SWIGINTERN int TradeCondition_OUTSIDE_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_OUTSIDE_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_OUTSIDE_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_OUTSIDE_SPREAD);
  return pyobj;
}


SWIGINTERN int TradeCondition_BUNCHED_SALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_BUNCHED_SALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_BUNCHED_SALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_BUNCHED_SALE);
  return pyobj;
}


SWIGINTERN int TradeCondition_CANCEL_STOPPED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CANCEL_STOPPED is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_CANCEL_STOPPED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_STOPPED);
  return pyobj;
}


SWIGINTERN int TradeCondition_LATE_OPEN_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_LATE_OPEN_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_LATE_OPEN_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_LATE_OPEN_ETH);
  return pyobj;
}


SWIGINTERN int TradeCondition_OPENING_REOPENING_TRADE_DETAIL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_OPENING_REOPENING_TRADE_DETAIL is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_OPENING_REOPENING_TRADE_DETAIL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_OPENING_REOPENING_TRADE_DETAIL);
  return pyobj;
}


SWIGINTERN int TradeCondition_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL);
  return pyobj;
}


SWIGINTERN int TradeCondition_COMBO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_COMBO is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_COMBO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_COMBO);
  return pyobj;
}


SWIGINTERN int TradeCondition_OPENING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_OPENING is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_OPENING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_OPENING);
  return pyobj;
}


SWIGINTERN int TradeCondition_ACQUISITION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_ACQUISITION is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_ACQUISITION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_ACQUISITION);
  return pyobj;
}


SWIGINTERN int TradeCondition_OPENED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_OPENED is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_OPENED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_OPENED);
  return pyobj;
}


SWIGINTERN int TradeCondition_CANCEL_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CANCEL_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_CANCEL_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_ONLY);
  return pyobj;
}


SWIGINTERN int TradeCondition_NEXT_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_NEXT_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_NEXT_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_NEXT_DAY);
  return pyobj;
}


SWIGINTERN int TradeCondition_BARGAIN_CONDITION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_BARGAIN_CONDITION is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_BARGAIN_CONDITION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_BARGAIN_CONDITION);
  return pyobj;
}


SWIGINTERN int TradeCondition_STOPPED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_STOPPED is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_STOPPED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_STOPPED);
  return pyobj;
}


SWIGINTERN int TradeCondition_CONVERTED_PRICE_INDICATOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CONVERTED_PRICE_INDICATOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_CONVERTED_PRICE_INDICATOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CONVERTED_PRICE_INDICATOR);
  return pyobj;
}


SWIGINTERN int TradeCondition_OFFICIAL_CLOSING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_OFFICIAL_CLOSING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_OFFICIAL_CLOSING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_OFFICIAL_CLOSING_PRICE);
  return pyobj;
}


SWIGINTERN int TradeCondition_ADJUSTED_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_ADJUSTED_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_ADJUSTED_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_ADJUSTED_ETH);
  return pyobj;
}


SWIGINTERN int TradeCondition_AVGPX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_AVGPX is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_AVGPX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_AVGPX);
  return pyobj;
}


SWIGINTERN int TradeCondition_RULE_155_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_RULE_155_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_RULE_155_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_RULE_155_TRADE);
  return pyobj;
}


SWIGINTERN int TradeCondition_SOLDLAST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_SOLDLAST is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_SOLDLAST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_SOLDLAST);
  return pyobj;
}


SWIGINTERN int TradeCondition_NEXTDAY_J_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_NEXTDAY_J is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_NEXTDAY_J_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_NEXTDAY_J);
  return pyobj;
}


SWIGINTERN int TradeCondition_AUTOMATIC_EXECUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_AUTOMATIC_EXECUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_AUTOMATIC_EXECUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_AUTOMATIC_EXECUTION);
  return pyobj;
}


SWIGINTERN int TradeCondition_CROSSED_X_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CROSSED_X is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_CROSSED_X_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CROSSED_X);
  return pyobj;
}


SWIGINTERN int TradeCondition_AUTO_EXECUTION_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_AUTO_EXECUTION_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_AUTO_EXECUTION_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_AUTO_EXECUTION_ETH);
  return pyobj;
}


SWIGINTERN int TradeCondition_MULTILEG_TO_MULTILEG_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_MULTILEG_TO_MULTILEG_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_MULTILEG_TO_MULTILEG_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_MULTILEG_TO_MULTILEG_TRADE);
  return pyobj;
}


SWIGINTERN int TradeCondition_OFFICAL_CLOSING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_OFFICAL_CLOSING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_OFFICAL_CLOSING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_OFFICAL_CLOSING_PRICE);
  return pyobj;
}


SWIGINTERN int TradeCondition_FINAL_PRICE_OF_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_FINAL_PRICE_OF_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_FINAL_PRICE_OF_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_FINAL_PRICE_OF_SESSION);
  return pyobj;
}


SWIGINTERN int TradeCondition_BASKET_INDEX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_BASKET_INDEX is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_BASKET_INDEX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_BASKET_INDEX);
  return pyobj;
}


SWIGINTERN int 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 *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 TradeCondition_STOPPED_STOCK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_STOPPED_STOCK is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_STOPPED_STOCK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_STOPPED_STOCK);
  return pyobj;
}


SWIGINTERN int 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 *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 TradeCondition_STOPPED_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_STOPPED_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_STOPPED_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_STOPPED_ETH);
  return pyobj;
}


SWIGINTERN int TradeCondition_REGULAR_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_REGULAR_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_REGULAR_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_REGULAR_ETH);
  return pyobj;
}


SWIGINTERN int TradeCondition_CANCEL_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CANCEL_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_CANCEL_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_OPEN);
  return pyobj;
}


SWIGINTERN int TradeCondition_CASH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CASH is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_CASH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CASH);
  return pyobj;
}


SWIGINTERN int TradeCondition_CASHTRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CASHTRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_CASHTRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CASHTRADE);
  return pyobj;
}


SWIGINTERN int TradeCondition_RULE155_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_RULE155 is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_RULE155_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_RULE155);
  return pyobj;
}


SWIGINTERN int TradeCondition_CANCEL_STOPPED_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CANCEL_STOPPED_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_CANCEL_STOPPED_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_STOPPED_ETH);
  return pyobj;
}


SWIGINTERN int TradeCondition_VOLUME_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_VOLUME_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_VOLUME_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_VOLUME_ONLY);
  return pyobj;
}


SWIGINTERN int TradeCondition_SPLIT_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_SPLIT_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_SPLIT_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_SPLIT_TRADE);
  return pyobj;
}


SWIGINTERN int TradeCondition_STOPPED_OUT_OF_SEQUENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_STOPPED_OUT_OF_SEQUENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_STOPPED_OUT_OF_SEQUENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_STOPPED_OUT_OF_SEQUENCE);
  return pyobj;
}


SWIGINTERN int TradeCondition_CASH_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CASH_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_CASH_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CASH_TRADE);
  return pyobj;
}


SWIGINTERN int TradeCondition_IMBALANCE_MORE_BUYERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_IMBALANCE_MORE_BUYERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_IMBALANCE_MORE_BUYERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_IMBALANCE_MORE_BUYERS);
  return pyobj;
}


SWIGINTERN int TradeCondition_BUNCHED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_BUNCHED is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_BUNCHED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_BUNCHED);
  return pyobj;
}


SWIGINTERN int TradeCondition_INTRADAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_INTRADAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_INTRADAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_INTRADAY);
  return pyobj;
}


SWIGINTERN int TradeCondition_IMBALANCE_MORE_SELLERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_IMBALANCE_MORE_SELLERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_IMBALANCE_MORE_SELLERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_IMBALANCE_MORE_SELLERS);
  return pyobj;
}


SWIGINTERN int TradeCondition_INTRADAY_TRADE_DETAIL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_INTRADAY_TRADE_DETAIL is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_INTRADAY_TRADE_DETAIL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_INTRADAY_TRADE_DETAIL);
  return pyobj;
}


SWIGINTERN int TradeCondition_RULE_127_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_RULE_127_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_RULE_127_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_RULE_127_TRADE);
  return pyobj;
}


SWIGINTERN int TradeCondition_IMBALANCEMOREBUYERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_IMBALANCEMOREBUYERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_IMBALANCEMOREBUYERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_IMBALANCEMOREBUYERS);
  return pyobj;
}


SWIGINTERN int TradeCondition_REOPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_REOPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_REOPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_REOPEN);
  return pyobj;
}


SWIGINTERN int TradeCondition_EX_PIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_EX_PIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_EX_PIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_EX_PIT);
  return pyobj;
}


SWIGINTERN int TradeCondition_CANCEL_LAST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CANCEL_LAST is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_CANCEL_LAST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_LAST);
  return pyobj;
}


SWIGINTERN int TradeCondition_DIRECT_PLUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_DIRECT_PLUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_DIRECT_PLUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_DIRECT_PLUS);
  return pyobj;
}


SWIGINTERN int TradeCondition_IMBALANCEMORESELLERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_IMBALANCEMORESELLERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_IMBALANCEMORESELLERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_IMBALANCEMORESELLERS);
  return pyobj;
}


SWIGINTERN int TradeCondition_AVERAGE_PRICE_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_AVERAGE_PRICE_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_AVERAGE_PRICE_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_AVERAGE_PRICE_TRADE);
  return pyobj;
}


SWIGINTERN int TradeCondition_SOLD_LAST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_SOLD_LAST is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_SOLD_LAST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_SOLD_LAST);
  return pyobj;
}


SWIGINTERN int TradeCondition_MARKETPLACE_ENTERED_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_MARKETPLACE_ENTERED_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_MARKETPLACE_ENTERED_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_MARKETPLACE_ENTERED_TRADE);
  return pyobj;
}


SWIGINTERN int TradeCondition_SPREAD_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_SPREAD_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_SPREAD_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_SPREAD_ETH);
  return pyobj;
}


SWIGINTERN int TradeCondition_CANCEL_OPEN_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CANCEL_OPEN_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_CANCEL_OPEN_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_OPEN_ETH);
  return pyobj;
}


SWIGINTERN int TradeCondition_EXCHANGE_LAST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_EXCHANGE_LAST is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_EXCHANGE_LAST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_EXCHANGE_LAST);
  return pyobj;
}


SWIGINTERN int TradeCondition_FAST_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_FAST_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_FAST_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_FAST_MARKET);
  return pyobj;
}


SWIGINTERN int TradeCondition_BURST_BASKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_BURST_BASKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_BURST_BASKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_BURST_BASKET);
  return pyobj;
}


SWIGINTERN int TradeCondition_SOLD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_SOLD is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeCondition_SOLD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_SOLD);
  return pyobj;
}


SWIGINTERN int PriceLimitType_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceLimitType_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PriceLimitType_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceLimitType_PRICE));
  return pyobj;
}


SWIGINTERN int PriceLimitType_TICKS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceLimitType_TICKS is read-only.");
  return 1;
}


SWIGINTERN PyObject *PriceLimitType_TICKS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceLimitType_TICKS));
  return pyobj;
}


SWIGINTERN int PriceLimitType_PERCENTAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceLimitType_PERCENTAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PriceLimitType_PERCENTAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceLimitType_PERCENTAGE));
  return pyobj;
}


SWIGINTERN int CommType_PER_SHARE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_PER_SHARE is read-only.");
  return 1;
}


SWIGINTERN PyObject *CommType_PER_SHARE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CommType_PER_SHARE));
  return pyobj;
}


SWIGINTERN int CommType_PCTWAIVEDCSHDISC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_PCTWAIVEDCSHDISC is read-only.");
  return 1;
}


SWIGINTERN PyObject *CommType_PCTWAIVEDCSHDISC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CommType_PCTWAIVEDCSHDISC));
  return pyobj;
}


SWIGINTERN int CommType_ABSOLUTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_ABSOLUTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *CommType_ABSOLUTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CommType_ABSOLUTE));
  return pyobj;
}


SWIGINTERN int CommType_PCTWAIVEDENUNITS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_PCTWAIVEDENUNITS is read-only.");
  return 1;
}


SWIGINTERN PyObject *CommType_PCTWAIVEDENUNITS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CommType_PCTWAIVEDENUNITS));
  return pyobj;
}


SWIGINTERN int CommType_PERBOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_PERBOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *CommType_PERBOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CommType_PERBOND));
  return pyobj;
}


SWIGINTERN int CommType_PER_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_PER_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *CommType_PER_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CommType_PER_BOND));
  return pyobj;
}


SWIGINTERN int CommType_PERCENTAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_PERCENTAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *CommType_PERCENTAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CommType_PERCENTAGE));
  return pyobj;
}


SWIGINTERN int CommType_PERCENTAGE_WAIVED_4_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_PERCENTAGE_WAIVED_4 is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 CommType_PERCENTAGE_WAIVED_5_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_PERCENTAGE_WAIVED_5 is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 CommType_PER_UNIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_PER_UNIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *CommType_PER_UNIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CommType_PER_UNIT));
  return pyobj;
}


SWIGINTERN int CommType_PERCENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_PERCENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *CommType_PERCENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CommType_PERCENT));
  return pyobj;
}


SWIGINTERN int CommType_4_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_4 is read-only.");
  return 1;
}


SWIGINTERN PyObject *CommType_4_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CommType_4));
  return pyobj;
}


SWIGINTERN int CommType_5_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_5 is read-only.");
  return 1;
}


SWIGINTERN PyObject *CommType_5_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CommType_5));
  return pyobj;
}


SWIGINTERN int 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 *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 RegistRejReasonCode_INVALIDOWNERSHIPTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALIDOWNERSHIPTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *RegistRejReasonCode_INVALIDOWNERSHIPTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDOWNERSHIPTYPE));
  return pyobj;
}


SWIGINTERN int RegistRejReasonCode_INVALIDREGDTLS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALIDREGDTLS is read-only.");
  return 1;
}


SWIGINTERN PyObject *RegistRejReasonCode_INVALIDREGDTLS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDREGDTLS));
  return pyobj;
}


SWIGINTERN int RegistRejReasonCode_INVALIDMAILINGDTLS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALIDMAILINGDTLS is read-only.");
  return 1;
}


SWIGINTERN PyObject *RegistRejReasonCode_INVALIDMAILINGDTLS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDMAILINGDTLS));
  return pyobj;
}


SWIGINTERN int RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DTLS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DTLS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INSTRUCTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INSTRUCTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 RegistRejReasonCode_INVALIDINVESTORCOUNTRYOFRESIDENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALIDINVESTORCOUNTRYOFRESIDENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *RegistRejReasonCode_INVALIDINVESTORCOUNTRYOFRESIDENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDINVESTORCOUNTRYOFRESIDENCE));
  return pyobj;
}


SWIGINTERN int RegistRejReasonCode_INVALIDCASHDISTRIBAGENTCODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALIDCASHDISTRIBAGENTCODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *RegistRejReasonCode_INVALIDCASHDISTRIBAGENTCODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDCASHDISTRIBAGENTCODE));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 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 *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 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 *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 RegistRejReasonCode_INVALIDDATEOFBIRTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALIDDATEOFBIRTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *RegistRejReasonCode_INVALIDDATEOFBIRTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDDATEOFBIRTH));
  return pyobj;
}


SWIGINTERN int RegistRejReasonCode_INVALIDDISTRIBPAYMENTMETHOD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALIDDISTRIBPAYMENTMETHOD is read-only.");
  return 1;
}


SWIGINTERN PyObject *RegistRejReasonCode_INVALIDDISTRIBPAYMENTMETHOD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDDISTRIBPAYMENTMETHOD));
  return pyobj;
}


SWIGINTERN int 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 *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 RegistRejReasonCode_INVALIDNODISTRIBINSTNS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALIDNODISTRIBINSTNS is read-only.");
  return 1;
}


SWIGINTERN PyObject *RegistRejReasonCode_INVALIDNODISTRIBINSTNS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDNODISTRIBINSTNS));
  return pyobj;
}


SWIGINTERN int RegistRejReasonCode_INVALIDCASHDISTRIBAGENTACCTNUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALIDCASHDISTRIBAGENTACCTNUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *RegistRejReasonCode_INVALIDCASHDISTRIBAGENTACCTNUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDCASHDISTRIBAGENTACCTNUM));
  return pyobj;
}


SWIGINTERN int RegistRejReasonCode_INVALIDTAXEXEMPTTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALIDTAXEXEMPTTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *RegistRejReasonCode_INVALIDTAXEXEMPTTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDTAXEXEMPTTYPE));
  return pyobj;
}


SWIGINTERN int RegistRejReasonCode_INVALIDMAILINGINST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALIDMAILINGINST is read-only.");
  return 1;
}


SWIGINTERN PyObject *RegistRejReasonCode_INVALIDMAILINGINST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDMAILINGINST));
  return pyobj;
}


SWIGINTERN int RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INST is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 RegistRejReasonCode_INVALIDACCOUNTTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALIDACCOUNTTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *RegistRejReasonCode_INVALIDACCOUNTTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDACCOUNTTYPE));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DETAILS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DETAILS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 RegistRejReasonCode_INVALIDREGSEQNO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALIDREGSEQNO is read-only.");
  return 1;
}


SWIGINTERN PyObject *RegistRejReasonCode_INVALIDREGSEQNO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDREGSEQNO));
  return pyobj;
}


SWIGINTERN int RegistRejReasonCode_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *RegistRejReasonCode_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_OTHER));
  return pyobj;
}


SWIGINTERN int RegistRejReasonCode_INVALIDDISTRIBPERCENTAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALIDDISTRIBPERCENTAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *RegistRejReasonCode_INVALIDDISTRIBPERCENTAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDDISTRIBPERCENTAGE));
  return pyobj;
}


SWIGINTERN int RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DTLS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DTLS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 RegistRejReasonCode_INVALID_UNACCEPTABLE_ACCOUNT_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_ACCOUNT_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DETAILS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DETAILS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 RegistRejReasonCode_INVALIDINVESTORIDSOURCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALIDINVESTORIDSOURCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *RegistRejReasonCode_INVALIDINVESTORIDSOURCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDINVESTORIDSOURCE));
  return pyobj;
}


SWIGINTERN int 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 *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 RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PERCENTAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PERCENTAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 RegistRejReasonCode_INVALIDCASHDISTRIBAGENTACCTNAME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALIDCASHDISTRIBAGENTACCTNAME is read-only.");
  return 1;
}


SWIGINTERN PyObject *RegistRejReasonCode_INVALIDCASHDISTRIBAGENTACCTNAME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDCASHDISTRIBAGENTACCTNAME));
  return pyobj;
}


SWIGINTERN int RegistRejReasonCode_INVALIDNOREGDETLS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALIDNOREGDETLS is read-only.");
  return 1;
}


SWIGINTERN PyObject *RegistRejReasonCode_INVALIDNOREGDETLS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDNOREGDETLS));
  return pyobj;
}


SWIGINTERN int RegistRejReasonCode_INVALIDINVESTORID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALIDINVESTORID is read-only.");
  return 1;
}


SWIGINTERN PyObject *RegistRejReasonCode_INVALIDINVESTORID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDINVESTORID));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 RegistRejReasonCode_INVALID_UNACCEPTABLE_OWNERSHIP_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_OWNERSHIP_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 RegistRejReasonCode_INVALID_UNACCEPTABLE_NODISTRIBINSTNS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_NODISTRIBINSTNS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 FinancialStatus_BANKRUPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FinancialStatus_BANKRUPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *FinancialStatus_BANKRUPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::FinancialStatus_BANKRUPT));
  return pyobj;
}


SWIGINTERN int FinancialStatus_PENDINGDELISTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FinancialStatus_PENDINGDELISTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *FinancialStatus_PENDINGDELISTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::FinancialStatus_PENDINGDELISTING));
  return pyobj;
}


SWIGINTERN int FinancialStatus_RESTRICTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FinancialStatus_RESTRICTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *FinancialStatus_RESTRICTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::FinancialStatus_RESTRICTED));
  return pyobj;
}


SWIGINTERN int FinancialStatus_PENDING_DELISTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FinancialStatus_PENDING_DELISTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *FinancialStatus_PENDING_DELISTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::FinancialStatus_PENDING_DELISTING));
  return pyobj;
}


SWIGINTERN int LastFragment_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastFragment_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *LastFragment_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LastFragment_NO));
  return pyobj;
}


SWIGINTERN int LastFragment_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastFragment_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *LastFragment_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LastFragment_YES));
  return pyobj;
}


SWIGINTERN int NotifyBrokerOfCredit_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NotifyBrokerOfCredit_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *NotifyBrokerOfCredit_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::NotifyBrokerOfCredit_NO));
  return pyobj;
}


SWIGINTERN int NotifyBrokerOfCredit_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NotifyBrokerOfCredit_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *NotifyBrokerOfCredit_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::NotifyBrokerOfCredit_YES));
  return pyobj;
}


SWIGINTERN int PartySubIDType_REGISTERED_ADDRESS_12_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_REGISTERED_ADDRESS_12 is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PartySubIDType_CASH_ACCOUNT_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_CASH_ACCOUNT_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PartySubIDType_FAX_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_FAX_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_FAX_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_FAX_NUMBER));
  return pyobj;
}


SWIGINTERN int PartySubIDType_CONTACTNAME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_CONTACTNAME is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_CONTACTNAME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_CONTACTNAME));
  return pyobj;
}


SWIGINTERN int PartySubIDType_RESERVEDANDAVAILABLEFORBILATERALLYAGREEDUPONUSERDEFINEDVALUES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_RESERVEDANDAVAILABLEFORBILATERALLYAGREEDUPONUSERDEFINEDVALUES is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_RESERVEDANDAVAILABLEFORBILATERALLYAGREEDUPONUSERDEFINEDVALUES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_RESERVEDANDAVAILABLEFORBILATERALLYAGREEDUPONUSERDEFINEDVALUES));
  return pyobj;
}


SWIGINTERN int PartySubIDType_DEPARTMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_DEPARTMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_DEPARTMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_DEPARTMENT));
  return pyobj;
}


SWIGINTERN int PartySubIDType_CONTACT_NAME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_CONTACT_NAME is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_CONTACT_NAME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_CONTACT_NAME));
  return pyobj;
}


SWIGINTERN int PartySubIDType_TELEXNUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_TELEXNUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_TELEXNUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_TELEXNUMBER));
  return pyobj;
}


SWIGINTERN int PartySubIDType_PERSON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_PERSON is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_PERSON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_PERSON));
  return pyobj;
}


SWIGINTERN int PartySubIDType_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_FIRM));
  return pyobj;
}


SWIGINTERN int PartySubIDType_CASH_ACCOUNT_NAME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_CASH_ACCOUNT_NAME is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PartySubIDType_POSITION_ACCOUNT_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_POSITION_ACCOUNT_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PartySubIDType_POSTAL_ADDRESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_POSTAL_ADDRESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_POSTAL_ADDRESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_POSTAL_ADDRESS));
  return pyobj;
}


SWIGINTERN int PartySubIDType_SECURITY_LOCATE_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_SECURITY_LOCATE_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PartySubIDType_POSTALADDRESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_POSTALADDRESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_POSTALADDRESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_POSTALADDRESS));
  return pyobj;
}


SWIGINTERN int PartySubIDType_FUND_ACCOUNT_NAME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_FUND_ACCOUNT_NAME is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PartySubIDType_PROFESSIONAL_CLIENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_PROFESSIONAL_CLIENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_PROFESSIONAL_CLIENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_PROFESSIONAL_CLIENT));
  return pyobj;
}


SWIGINTERN int PartySubIDType_LOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_LOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_LOCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_LOCATION));
  return pyobj;
}


SWIGINTERN int PartySubIDType_FULLLEGALNAMEOFFIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_FULLLEGALNAMEOFFIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_FULLLEGALNAMEOFFIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_FULLLEGALNAMEOFFIRM));
  return pyobj;
}


SWIGINTERN int PartySubIDType_LOCATIONDESK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_LOCATIONDESK is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_LOCATIONDESK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_LOCATIONDESK));
  return pyobj;
}


SWIGINTERN int PartySubIDType_REGISTEREDADDRESS_12_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_REGISTEREDADDRESS_12 is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_REGISTEREDADDRESS_12_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REGISTEREDADDRESS_12));
  return pyobj;
}


SWIGINTERN int PartySubIDType_REGISTRATION_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_REGISTRATION_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_REGISTRATION_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REGISTRATION_NUMBER));
  return pyobj;
}


SWIGINTERN int PartySubIDType_EMAILADDRESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_EMAILADDRESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_EMAILADDRESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_EMAILADDRESS));
  return pyobj;
}


SWIGINTERN int PartySubIDType_SYSTEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_SYSTEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_SYSTEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_SYSTEM));
  return pyobj;
}


SWIGINTERN int PartySubIDType_SECURITIESACCOUNTNUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_SECURITIESACCOUNTNUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_SECURITIESACCOUNTNUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_SECURITIESACCOUNTNUMBER));
  return pyobj;
}


SWIGINTERN int PartySubIDType_REGULATORY_STATUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_REGULATORY_STATUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_REGULATORY_STATUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REGULATORY_STATUS));
  return pyobj;
}


SWIGINTERN int PartySubIDType_CSD_PARTICIPANT_MEMBER_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_CSD_PARTICIPANT_MEMBER_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PartySubIDType_PHONENUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_PHONENUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_PHONENUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_PHONENUMBER));
  return pyobj;
}


SWIGINTERN int PartySubIDType_CURRENCY_DELIVERY_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_CURRENCY_DELIVERY_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PartySubIDType_REGISTRATION_NAME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_REGISTRATION_NAME is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_REGISTRATION_NAME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REGISTRATION_NAME));
  return pyobj;
}


SWIGINTERN int PartySubIDType_REGISTERED_ADDRESS_18_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_REGISTERED_ADDRESS_18 is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PartySubIDType_TELEX_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_TELEX_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_TELEX_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_TELEX_NUMBER));
  return pyobj;
}


SWIGINTERN int PartySubIDType_EMAIL_ADDRESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_EMAIL_ADDRESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_EMAIL_ADDRESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_EMAIL_ADDRESS));
  return pyobj;
}


SWIGINTERN int PartySubIDType_FAXNUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_FAXNUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_FAXNUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_FAXNUMBER));
  return pyobj;
}


SWIGINTERN int PartySubIDType_BIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_BIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_BIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_BIC));
  return pyobj;
}


SWIGINTERN int PartySubIDType_CASHACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_CASHACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_CASHACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_CASHACCOUNT));
  return pyobj;
}


SWIGINTERN int PartySubIDType_REGISTRATIONNUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_REGISTRATIONNUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_REGISTRATIONNUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REGISTRATIONNUMBER));
  return pyobj;
}


SWIGINTERN int PartySubIDType_LOCATION_DESK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_LOCATION_DESK is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_LOCATION_DESK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_LOCATION_DESK));
  return pyobj;
}


SWIGINTERN int PartySubIDType_APPLICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_APPLICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_APPLICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_APPLICATION));
  return pyobj;
}


SWIGINTERN int PartySubIDType_CASHACCOUNTNAME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_CASHACCOUNTNAME is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_CASHACCOUNTNAME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_CASHACCOUNTNAME));
  return pyobj;
}


SWIGINTERN int PartySubIDType_SECURITIES_ACCOUNT_NAME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_SECURITIES_ACCOUNT_NAME is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PartySubIDType_PHONE_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_PHONE_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_PHONE_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_PHONE_NUMBER));
  return pyobj;
}


SWIGINTERN int PartySubIDType_SECURITIESACCOUNTNAME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_SECURITIESACCOUNTNAME is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_SECURITIESACCOUNTNAME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_SECURITIESACCOUNTNAME));
  return pyobj;
}


SWIGINTERN int PartySubIDType_REGISTRATIONNAME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_REGISTRATIONNAME is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_REGISTRATIONNAME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REGISTRATIONNAME));
  return pyobj;
}


SWIGINTERN int PartySubIDType_ELIGIBLE_COUNTERPARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_ELIGIBLE_COUNTERPARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_ELIGIBLE_COUNTERPARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_ELIGIBLE_COUNTERPARTY));
  return pyobj;
}


SWIGINTERN int PartySubIDType_REGISTEREDADDRESS_18_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_REGISTEREDADDRESS_18 is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_REGISTEREDADDRESS_18_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REGISTEREDADDRESS_18));
  return pyobj;
}


SWIGINTERN int PartySubIDType_SECURITIES_ACCOUNT_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_SECURITIES_ACCOUNT_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 PartySubIDType_MARKET_MAKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_MARKET_MAKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_MARKET_MAKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_MARKET_MAKER));
  return pyobj;
}


SWIGINTERN int PartySubIDType_EXECUTION_VENUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_EXECUTION_VENUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_EXECUTION_VENUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_EXECUTION_VENUE));
  return pyobj;
}


SWIGINTERN int PartySubIDType_POSITIONACCOUNTTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_POSITIONACCOUNTTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_POSITIONACCOUNTTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_POSITIONACCOUNTTYPE));
  return pyobj;
}


SWIGINTERN int PartySubIDType_FUNDACCOUNTNAME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_FUNDACCOUNTNAME is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_FUNDACCOUNTNAME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_FUNDACCOUNTNAME));
  return pyobj;
}


SWIGINTERN int PartySubIDType_CSDPARTICIPANTMEMBERCODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_CSDPARTICIPANTMEMBERCODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_CSDPARTICIPANTMEMBERCODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_CSDPARTICIPANTMEMBERCODE));
  return pyobj;
}


SWIGINTERN int PartySubIDType_REGULATORYSTATUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_REGULATORYSTATUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartySubIDType_REGULATORYSTATUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REGULATORYSTATUS));
  return pyobj;
}


SWIGINTERN int AllocNoOrdersType_EXPLICIT_LIST_PROVIDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocNoOrdersType_EXPLICIT_LIST_PROVIDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 AllocNoOrdersType_NOTSPECIFIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocNoOrdersType_NOTSPECIFIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocNoOrdersType_NOTSPECIFIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocNoOrdersType_NOTSPECIFIED));
  return pyobj;
}


SWIGINTERN int AllocNoOrdersType_NOT_SPECIFIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocNoOrdersType_NOT_SPECIFIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocNoOrdersType_NOT_SPECIFIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocNoOrdersType_NOT_SPECIFIED));
  return pyobj;
}


SWIGINTERN int AllocNoOrdersType_EXPLICITLISTPROVIDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocNoOrdersType_EXPLICITLISTPROVIDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocNoOrdersType_EXPLICITLISTPROVIDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocNoOrdersType_EXPLICITLISTPROVIDED));
  return pyobj;
}


SWIGINTERN int AllocLinkType_FX_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocLinkType_FX_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocLinkType_FX_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocLinkType_FX_SWAP));
  return pyobj;
}


SWIGINTERN int AllocLinkType_F_X_NETTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocLinkType_F_X_NETTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 AllocLinkType_FXNETTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocLinkType_FXNETTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocLinkType_FXNETTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocLinkType_FXNETTING));
  return pyobj;
}


SWIGINTERN int AllocLinkType_FX_NETTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocLinkType_FX_NETTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocLinkType_FX_NETTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocLinkType_FX_NETTING));
  return pyobj;
}


SWIGINTERN int AllocLinkType_FXSWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocLinkType_FXSWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocLinkType_FXSWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocLinkType_FXSWAP));
  return pyobj;
}


SWIGINTERN int AllocLinkType_F_X_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocLinkType_F_X_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 UnderlyingSettlementType_T_PLUS_1_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingSettlementType_T_PLUS_1 is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 UnderlyingSettlementType_T_PLUS_3_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingSettlementType_T_PLUS_3 is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 UnderlyingSettlementType_T_PLUS_4_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingSettlementType_T_PLUS_4 is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 DisplayMethod_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DisplayMethod_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *DisplayMethod_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DisplayMethod_NEW));
  return pyobj;
}


SWIGINTERN int DisplayMethod_UNDISCLOSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DisplayMethod_UNDISCLOSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *DisplayMethod_UNDISCLOSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DisplayMethod_UNDISCLOSED));
  return pyobj;
}


SWIGINTERN int DisplayMethod_RANDOM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DisplayMethod_RANDOM is read-only.");
  return 1;
}


SWIGINTERN PyObject *DisplayMethod_RANDOM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DisplayMethod_RANDOM));
  return pyobj;
}


SWIGINTERN int DisplayMethod_INITIAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DisplayMethod_INITIAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *DisplayMethod_INITIAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DisplayMethod_INITIAL));
  return pyobj;
}


SWIGINTERN int CollStatus_PARTIALLY_ASSIGNED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollStatus_PARTIALLY_ASSIGNED is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollStatus_PARTIALLY_ASSIGNED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollStatus_PARTIALLY_ASSIGNED));
  return pyobj;
}


SWIGINTERN int CollStatus_ASSIGNEDACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollStatus_ASSIGNEDACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollStatus_ASSIGNEDACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollStatus_ASSIGNEDACCEPTED));
  return pyobj;
}


SWIGINTERN int CollStatus_ASSIGNMENT_PROPOSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollStatus_ASSIGNMENT_PROPOSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollStatus_ASSIGNMENT_PROPOSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollStatus_ASSIGNMENT_PROPOSED));
  return pyobj;
}


SWIGINTERN int CollStatus_ASSIGNED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollStatus_ASSIGNED is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollStatus_ASSIGNED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollStatus_ASSIGNED));
  return pyobj;
}


SWIGINTERN int CollStatus_CHALLENGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollStatus_CHALLENGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollStatus_CHALLENGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollStatus_CHALLENGED));
  return pyobj;
}


SWIGINTERN int CollStatus_UNASSIGNED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollStatus_UNASSIGNED is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollStatus_UNASSIGNED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollStatus_UNASSIGNED));
  return pyobj;
}


SWIGINTERN int CollStatus_ASSIGNMENTPROPOSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollStatus_ASSIGNMENTPROPOSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollStatus_ASSIGNMENTPROPOSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollStatus_ASSIGNMENTPROPOSED));
  return pyobj;
}


SWIGINTERN int CollStatus_PARTIALLYASSIGNED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollStatus_PARTIALLYASSIGNED is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollStatus_PARTIALLYASSIGNED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollStatus_PARTIALLYASSIGNED));
  return pyobj;
}


SWIGINTERN int SideValueInd_SIDEVALUE_2_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideValueInd_SIDEVALUE_2 is read-only.");
  return 1;
}


SWIGINTERN PyObject *SideValueInd_SIDEVALUE_2_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideValueInd_SIDEVALUE_2));
  return pyobj;
}


SWIGINTERN int SideValueInd_SIDEVALUE1_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideValueInd_SIDEVALUE1 is read-only.");
  return 1;
}


SWIGINTERN PyObject *SideValueInd_SIDEVALUE1_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideValueInd_SIDEVALUE1));
  return pyobj;
}


SWIGINTERN int SideValueInd_SIDEVALUE2_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideValueInd_SIDEVALUE2 is read-only.");
  return 1;
}


SWIGINTERN PyObject *SideValueInd_SIDEVALUE2_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideValueInd_SIDEVALUE2));
  return pyobj;
}


SWIGINTERN int SideValueInd_SIDE_VALUE_1_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideValueInd_SIDE_VALUE_1 is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SideValueInd_SIDE_VALUE_2_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideValueInd_SIDE_VALUE_2 is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MsgDirection_RECEIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgDirection_RECEIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgDirection_RECEIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MsgDirection_RECEIVE));
  return pyobj;
}


SWIGINTERN int MsgDirection_SEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgDirection_SEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *MsgDirection_SEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MsgDirection_SEND));
  return pyobj;
}


SWIGINTERN int MDUpdateAction_DELETE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDUpdateAction_DELETE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDUpdateAction_DELETE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDUpdateAction_DELETE));
  return pyobj;
}


SWIGINTERN int MDUpdateAction_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDUpdateAction_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDUpdateAction_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDUpdateAction_NEW));
  return pyobj;
}


SWIGINTERN int MDUpdateAction_DELETE_THRU_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDUpdateAction_DELETE_THRU is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDUpdateAction_DELETE_THRU_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDUpdateAction_DELETE_THRU));
  return pyobj;
}


SWIGINTERN int MDUpdateAction_DELETE_FROM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDUpdateAction_DELETE_FROM is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDUpdateAction_DELETE_FROM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDUpdateAction_DELETE_FROM));
  return pyobj;
}


SWIGINTERN int MDUpdateAction_OVERLAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDUpdateAction_OVERLAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDUpdateAction_OVERLAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDUpdateAction_OVERLAY));
  return pyobj;
}


SWIGINTERN int MDUpdateAction_CHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDUpdateAction_CHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDUpdateAction_CHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDUpdateAction_CHANGE));
  return pyobj;
}


SWIGINTERN int MatchStatus_ADVALERT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchStatus_ADVALERT is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchStatus_ADVALERT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MatchStatus_ADVALERT));
  return pyobj;
}


SWIGINTERN int MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MatchStatus_COMPARED_MATCHED_OR_AFFIRMED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchStatus_COMPARED_MATCHED_OR_AFFIRMED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MatchStatus_ADVISORY_OR_ALERT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchStatus_ADVISORY_OR_ALERT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MatchStatus_UNCOMPUNMATUNAFF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchStatus_UNCOMPUNMATUNAFF is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchStatus_UNCOMPUNMATUNAFF_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MatchStatus_UNCOMPUNMATUNAFF));
  return pyobj;
}


SWIGINTERN int MatchStatus_COMPMATAFF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchStatus_COMPMATAFF is read-only.");
  return 1;
}


SWIGINTERN PyObject *MatchStatus_COMPMATAFF_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MatchStatus_COMPMATAFF));
  return pyobj;
}


SWIGINTERN int MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRMED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRMED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 RateSource_REUTERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RateSource_REUTERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *RateSource_REUTERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RateSource_REUTERS));
  return pyobj;
}


SWIGINTERN int RateSource_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RateSource_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *RateSource_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RateSource_OTHER));
  return pyobj;
}


SWIGINTERN int RateSource_BLOOMBERG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RateSource_BLOOMBERG is read-only.");
  return 1;
}


SWIGINTERN PyObject *RateSource_BLOOMBERG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RateSource_BLOOMBERG));
  return pyobj;
}


SWIGINTERN int RateSource_TELERATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RateSource_TELERATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *RateSource_TELERATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RateSource_TELERATE));
  return pyobj;
}


SWIGINTERN int AllocPositionEffect_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocPositionEffect_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocPositionEffect_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocPositionEffect_CLOSE));
  return pyobj;
}


SWIGINTERN int AllocPositionEffect_FIFO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocPositionEffect_FIFO is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocPositionEffect_FIFO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocPositionEffect_FIFO));
  return pyobj;
}


SWIGINTERN int AllocPositionEffect_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocPositionEffect_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocPositionEffect_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocPositionEffect_OPEN));
  return pyobj;
}


SWIGINTERN int AllocPositionEffect_ROLLED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocPositionEffect_ROLLED is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocPositionEffect_ROLLED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocPositionEffect_ROLLED));
  return pyobj;
}


SWIGINTERN int 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 *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 PartyIDSource_PROPRIETARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_PROPRIETARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyIDSource_PROPRIETARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_PROPRIETARY));
  return pyobj;
}


SWIGINTERN int PartyIDSource_USEMPLOYERIDNUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_USEMPLOYERIDNUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyIDSource_USEMPLOYERIDNUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_USEMPLOYERIDNUMBER));
  return pyobj;
}


SWIGINTERN int PartyIDSource_ACCPTMARKETPART_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_ACCPTMARKETPART is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyIDSource_ACCPTMARKETPART_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_ACCPTMARKETPART));
  return pyobj;
}


SWIGINTERN int PartyIDSource_CSDPARTCODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_CSDPARTCODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyIDSource_CSDPARTCODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_CSDPARTCODE));
  return pyobj;
}


SWIGINTERN int PartyIDSource_AUSTRALIAN_TAX_FILE_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_AUSTRALIAN_TAX_FILE_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PartyIDSource_KOREANINVESTORID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_KOREANINVESTORID is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyIDSource_KOREANINVESTORID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_KOREANINVESTORID));
  return pyobj;
}


SWIGINTERN int 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 *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 PartyIDSource_AUSTRALIAN_BUSINESS_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_AUSTRALIAN_BUSINESS_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PartyIDSource_US_EMPLOYER_IDENTIFICATION_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_US_EMPLOYER_IDENTIFICATION_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PartyIDSource_AUSTRALIANTAXFILENUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_AUSTRALIANTAXFILENUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyIDSource_AUSTRALIANTAXFILENUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_AUSTRALIANTAXFILENUMBER));
  return pyobj;
}


SWIGINTERN int PartyIDSource_TAIWANESE_TRADING_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_TAIWANESE_TRADING_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PartyIDSource_TAIWANESE_TRADING_ACCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_TAIWANESE_TRADING_ACCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PartyIDSource_CHINESEBSHARE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_CHINESEBSHARE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyIDSource_CHINESEBSHARE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_CHINESEBSHARE));
  return pyobj;
}


SWIGINTERN int PartyIDSource_AUSTRALIANBUSINESSNUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_AUSTRALIANBUSINESSNUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyIDSource_AUSTRALIANBUSINESSNUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_AUSTRALIANBUSINESSNUMBER));
  return pyobj;
}


SWIGINTERN int PartyIDSource_MALAYSIAN_CENTRAL_DEPOSITORY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_MALAYSIAN_CENTRAL_DEPOSITORY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PartyIDSource_US_SOCIAL_SECURITY_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_US_SOCIAL_SECURITY_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PartyIDSource_TAIWANESEQUALIFIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_TAIWANESEQUALIFIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyIDSource_TAIWANESEQUALIFIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_TAIWANESEQUALIFIED));
  return pyobj;
}


SWIGINTERN int PartyIDSource_USSOCIALSECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_USSOCIALSECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyIDSource_USSOCIALSECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_USSOCIALSECURITY));
  return pyobj;
}


SWIGINTERN int PartyIDSource_DIRECTEDDEFINEDISITC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_DIRECTEDDEFINEDISITC is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyIDSource_DIRECTEDDEFINEDISITC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_DIRECTEDDEFINEDISITC));
  return pyobj;
}


SWIGINTERN int 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 *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 PartyIDSource_CSD_PARTICIPANT_MEMBER_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_CSD_PARTICIPANT_MEMBER_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 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 *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 PartyIDSource_SETTLEMENT_ENTITY_LOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_SETTLEMENT_ENTITY_LOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PartyIDSource_PROPRIETARY_CUSTOM_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_PROPRIETARY_CUSTOM_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PartyIDSource_UKNATIONALINSPENNUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_UKNATIONALINSPENNUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyIDSource_UKNATIONALINSPENNUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_UKNATIONALINSPENNUMBER));
  return pyobj;
}


SWIGINTERN int PartyIDSource_BIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_BIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyIDSource_BIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_BIC));
  return pyobj;
}


SWIGINTERN int PartyIDSource_CHINESE_INVESTOR_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_CHINESE_INVESTOR_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PartyIDSource_TAIWANESETRADINGACCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_TAIWANESETRADINGACCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyIDSource_TAIWANESETRADINGACCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_TAIWANESETRADINGACCT));
  return pyobj;
}


SWIGINTERN int PartyIDSource_MIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_MIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyIDSource_MIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_MIC));
  return pyobj;
}


SWIGINTERN int PartyIDSource_KOREAN_INVESTOR_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_KOREAN_INVESTOR_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PartyIDSource_ISO_COUNTRY_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_ISO_COUNTRY_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 PartyIDSource_PROPCODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_PROPCODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyIDSource_PROPCODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_PROPCODE));
  return pyobj;
}


SWIGINTERN int PartyIDSource_ISOCODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_ISOCODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyIDSource_ISOCODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_ISOCODE));
  return pyobj;
}


SWIGINTERN int PartyIDSource_CHINESE_B_SHARE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_CHINESE_B_SHARE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PartyIDSource_MCDNUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_MCDNUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyIDSource_MCDNUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_MCDNUMBER));
  return pyobj;
}


SWIGINTERN int PartyIDSource_SETTLENTLOC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_SETTLENTLOC is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyIDSource_SETTLENTLOC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_SETTLENTLOC));
  return pyobj;
}


SWIGINTERN int ExchangeForPhysical_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExchangeForPhysical_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExchangeForPhysical_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExchangeForPhysical_NO));
  return pyobj;
}


SWIGINTERN int ExchangeForPhysical_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExchangeForPhysical_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExchangeForPhysical_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExchangeForPhysical_YES));
  return pyobj;
}


SWIGINTERN int 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 *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 SecurityTradingEvent_CHANGE_OF_TRADING_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingEvent_CHANGE_OF_TRADING_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SecurityTradingEvent_CHANGE_OF_SECURITY_STATUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingEvent_CHANGE_OF_SECURITY_STATUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SecurityTradingEvent_PRICE_VOLATILITY_INTERRUPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingEvent_PRICE_VOLATILITY_INTERRUPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SecurityTradingEvent_CHANGE_OF_BOOK_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingEvent_CHANGE_OF_BOOK_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SecurityTradingEvent_CHANGE_OF_TRADING_SUBSESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingEvent_CHANGE_OF_TRADING_SUBSESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SecurityTradingEvent_CHANGE_OF_MARKET_DEPTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingEvent_CHANGE_OF_MARKET_DEPTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SecurityTradingEvent_TRADING_RESUMES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingEvent_TRADING_RESUMES is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingEvent_TRADING_RESUMES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingEvent_TRADING_RESUMES));
  return pyobj;
}


SWIGINTERN int 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 *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 CollAction_ADD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAction_ADD is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollAction_ADD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAction_ADD));
  return pyobj;
}


SWIGINTERN int CollAction_REMOVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAction_REMOVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollAction_REMOVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAction_REMOVE));
  return pyobj;
}


SWIGINTERN int CollAction_RETAIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAction_RETAIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *CollAction_RETAIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAction_RETAIN));
  return pyobj;
}


SWIGINTERN int PossDupFlag_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PossDupFlag_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *PossDupFlag_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PossDupFlag_NO));
  return pyobj;
}


SWIGINTERN int PossDupFlag_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PossDupFlag_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *PossDupFlag_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PossDupFlag_YES));
  return pyobj;
}


SWIGINTERN int ListStatusType_ALL_DONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListStatusType_ALL_DONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListStatusType_ALL_DONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListStatusType_ALL_DONE));
  return pyobj;
}


SWIGINTERN int ListStatusType_TIMED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListStatusType_TIMED is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListStatusType_TIMED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListStatusType_TIMED));
  return pyobj;
}


SWIGINTERN int ListStatusType_RESP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListStatusType_RESP is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListStatusType_RESP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListStatusType_RESP));
  return pyobj;
}


SWIGINTERN int ListStatusType_EXECSTARTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListStatusType_EXECSTARTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListStatusType_EXECSTARTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListStatusType_EXECSTARTED));
  return pyobj;
}


SWIGINTERN int ListStatusType_RESPONSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListStatusType_RESPONSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListStatusType_RESPONSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListStatusType_RESPONSE));
  return pyobj;
}


SWIGINTERN int ListStatusType_ALLDONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListStatusType_ALLDONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListStatusType_ALLDONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListStatusType_ALLDONE));
  return pyobj;
}


SWIGINTERN int ListStatusType_ALERT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListStatusType_ALERT is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListStatusType_ALERT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListStatusType_ALERT));
  return pyobj;
}


SWIGINTERN int ListStatusType_ACK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListStatusType_ACK is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListStatusType_ACK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListStatusType_ACK));
  return pyobj;
}


SWIGINTERN int ListStatusType_EXEC_STARTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListStatusType_EXEC_STARTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListStatusType_EXEC_STARTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListStatusType_EXEC_STARTED));
  return pyobj;
}


SWIGINTERN int ListStatusType_EXECSTART_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListStatusType_EXECSTART is read-only.");
  return 1;
}


SWIGINTERN PyObject *ListStatusType_EXECSTART_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListStatusType_EXECSTART));
  return pyobj;
}


SWIGINTERN int GapFillFlag_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable GapFillFlag_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *GapFillFlag_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::GapFillFlag_NO));
  return pyobj;
}


SWIGINTERN int GapFillFlag_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable GapFillFlag_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *GapFillFlag_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::GapFillFlag_YES));
  return pyobj;
}


SWIGINTERN int TradeHandlingInstr_AUTOMATED_FLOOR_ORDER_ROUTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeHandlingInstr_AUTOMATED_FLOOR_ORDER_ROUTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 TradeHandlingInstr_TWO_PARTY_REPORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeHandlingInstr_TWO_PARTY_REPORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 TradeHandlingInstr_TRADE_CONFIRMATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeHandlingInstr_TRADE_CONFIRMATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeHandlingInstr_TRADE_CONFIRMATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradeHandlingInstr_TRADE_CONFIRMATION));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 TradSesMethod_TWOPARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesMethod_TWOPARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradSesMethod_TWOPARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesMethod_TWOPARTY));
  return pyobj;
}


SWIGINTERN int TradSesMethod_ELECTRONIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesMethod_ELECTRONIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradSesMethod_ELECTRONIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesMethod_ELECTRONIC));
  return pyobj;
}


SWIGINTERN int TradSesMethod_OPENOUTCRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesMethod_OPENOUTCRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradSesMethod_OPENOUTCRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesMethod_OPENOUTCRY));
  return pyobj;
}


SWIGINTERN int TradSesMethod_TWO_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesMethod_TWO_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradSesMethod_TWO_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesMethod_TWO_PARTY));
  return pyobj;
}


SWIGINTERN int TradSesMethod_OPEN_OUTCRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesMethod_OPEN_OUTCRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradSesMethod_OPEN_OUTCRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesMethod_OPEN_OUTCRY));
  return pyobj;
}


SWIGINTERN int TradeType_AGENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeType_AGENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeType_AGENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradeType_AGENCY));
  return pyobj;
}


SWIGINTERN int TradeType_VWAP_GUARANTEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeType_VWAP_GUARANTEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeType_VWAP_GUARANTEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradeType_VWAP_GUARANTEE));
  return pyobj;
}


SWIGINTERN int TradeType_RISK_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeType_RISK_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeType_RISK_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradeType_RISK_TRADE));
  return pyobj;
}


SWIGINTERN int TradeType_GUARANTEED_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeType_GUARANTEED_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TradeType_GUARANTEED_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradeType_GUARANTEED_CLOSE));
  return pyobj;
}


SWIGINTERN int ComplexEventCondition_AND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventCondition_AND is read-only.");
  return 1;
}


SWIGINTERN PyObject *ComplexEventCondition_AND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventCondition_AND));
  return pyobj;
}


SWIGINTERN int ComplexEventCondition_OR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventCondition_OR is read-only.");
  return 1;
}


SWIGINTERN PyObject *ComplexEventCondition_OR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventCondition_OR));
  return pyobj;
}


SWIGINTERN int BenchmarkCurveName_SONIA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_SONIA is read-only.");
  return 1;
}


SWIGINTERN PyObject *BenchmarkCurveName_SONIA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_SONIA);
  return pyobj;
}


SWIGINTERN int BenchmarkCurveName_MUNIAAA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_MUNIAAA is read-only.");
  return 1;
}


SWIGINTERN PyObject *BenchmarkCurveName_MUNIAAA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_MUNIAAA);
  return pyobj;
}


SWIGINTERN int BenchmarkCurveName_LIBID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_LIBID is read-only.");
  return 1;
}


SWIGINTERN PyObject *BenchmarkCurveName_LIBID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_LIBID);
  return pyobj;
}


SWIGINTERN int BenchmarkCurveName_PFANDBRIEFE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_PFANDBRIEFE is read-only.");
  return 1;
}


SWIGINTERN PyObject *BenchmarkCurveName_PFANDBRIEFE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_PFANDBRIEFE);
  return pyobj;
}


SWIGINTERN int BenchmarkCurveName_EUREPO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_EUREPO is read-only.");
  return 1;
}


SWIGINTERN PyObject *BenchmarkCurveName_EUREPO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_EUREPO);
  return pyobj;
}


SWIGINTERN int BenchmarkCurveName_FUTURESWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_FUTURESWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *BenchmarkCurveName_FUTURESWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_FUTURESWAP);
  return pyobj;
}


SWIGINTERN int BenchmarkCurveName_TREASURY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_TREASURY is read-only.");
  return 1;
}


SWIGINTERN PyObject *BenchmarkCurveName_TREASURY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_TREASURY);
  return pyobj;
}


SWIGINTERN int BenchmarkCurveName_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *BenchmarkCurveName_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_OTHER);
  return pyobj;
}


SWIGINTERN int BenchmarkCurveName_EURIBOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_EURIBOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *BenchmarkCurveName_EURIBOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_EURIBOR);
  return pyobj;
}


SWIGINTERN int BenchmarkCurveName_EONIA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_EONIA is read-only.");
  return 1;
}


SWIGINTERN PyObject *BenchmarkCurveName_EONIA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_EONIA);
  return pyobj;
}


SWIGINTERN int BenchmarkCurveName_LIBOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_LIBOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *BenchmarkCurveName_LIBOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_LIBOR);
  return pyobj;
}


SWIGINTERN int BenchmarkCurveName_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *BenchmarkCurveName_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_SWAP);
  return pyobj;
}


SWIGINTERN int CashMargin_MARGINCLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CashMargin_MARGINCLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *CashMargin_MARGINCLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CashMargin_MARGINCLOSE));
  return pyobj;
}


SWIGINTERN int CashMargin_MARGINOPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CashMargin_MARGINOPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *CashMargin_MARGINOPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CashMargin_MARGINOPEN));
  return pyobj;
}


SWIGINTERN int CashMargin_MARGIN_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CashMargin_MARGIN_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *CashMargin_MARGIN_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CashMargin_MARGIN_CLOSE));
  return pyobj;
}


SWIGINTERN int CashMargin_MARGIN_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CashMargin_MARGIN_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *CashMargin_MARGIN_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CashMargin_MARGIN_OPEN));
  return pyobj;
}


SWIGINTERN int CashMargin_CASH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CashMargin_CASH is read-only.");
  return 1;
}


SWIGINTERN PyObject *CashMargin_CASH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CashMargin_CASH));
  return pyobj;
}


SWIGINTERN int SettlObligTransType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlObligTransType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlObligTransType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlObligTransType_REPLACE));
  return pyobj;
}


SWIGINTERN int SettlObligTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlObligTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlObligTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlObligTransType_NEW));
  return pyobj;
}


SWIGINTERN int SettlObligTransType_RESTATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlObligTransType_RESTATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlObligTransType_RESTATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlObligTransType_RESTATE));
  return pyobj;
}


SWIGINTERN int SettlObligTransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlObligTransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlObligTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlObligTransType_CANCEL));
  return pyobj;
}


SWIGINTERN int DeskOrderHandlingInst_PEGGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_PEGGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskOrderHandlingInst_PEGGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_PEGGED);
  return pyobj;
}


SWIGINTERN int DeskOrderHandlingInst_MARKET_ON_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_MARKET_ON_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskOrderHandlingInst_MARKET_ON_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_MARKET_ON_OPEN);
  return pyobj;
}


SWIGINTERN int DeskOrderHandlingInst_SCALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_SCALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskOrderHandlingInst_SCALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_SCALE);
  return pyobj;
}


SWIGINTERN int DeskOrderHandlingInst_FILL_OR_KILL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_FILL_OR_KILL is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskOrderHandlingInst_FILL_OR_KILL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_FILL_OR_KILL);
  return pyobj;
}


SWIGINTERN int DeskOrderHandlingInst_ALL_OR_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_ALL_OR_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskOrderHandlingInst_ALL_OR_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_ALL_OR_NONE);
  return pyobj;
}


SWIGINTERN int DeskOrderHandlingInst_NOT_HELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_NOT_HELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskOrderHandlingInst_NOT_HELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_NOT_HELD);
  return pyobj;
}


SWIGINTERN int DeskOrderHandlingInst_DIRECTED_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_DIRECTED_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskOrderHandlingInst_DIRECTED_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_DIRECTED_ORDER);
  return pyobj;
}


SWIGINTERN int DeskOrderHandlingInst_STOP_STOCK_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_STOP_STOCK_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskOrderHandlingInst_STOP_STOCK_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_STOP_STOCK_TRANSACTION);
  return pyobj;
}


SWIGINTERN int DeskOrderHandlingInst_OVER_THE_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_OVER_THE_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskOrderHandlingInst_OVER_THE_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_OVER_THE_DAY);
  return pyobj;
}


SWIGINTERN int DeskOrderHandlingInst_ADD_ON_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_ADD_ON_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskOrderHandlingInst_ADD_ON_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_ADD_ON_ORDER);
  return pyobj;
}


SWIGINTERN int DeskOrderHandlingInst_MARKET_AT_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_MARKET_AT_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskOrderHandlingInst_MARKET_AT_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_MARKET_AT_CLOSE);
  return pyobj;
}


SWIGINTERN int DeskOrderHandlingInst_LIMIT_ON_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_LIMIT_ON_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskOrderHandlingInst_LIMIT_ON_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_LIMIT_ON_OPEN);
  return pyobj;
}


SWIGINTERN int DeskOrderHandlingInst_CASH_NOT_HELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_CASH_NOT_HELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskOrderHandlingInst_CASH_NOT_HELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_CASH_NOT_HELD);
  return pyobj;
}


SWIGINTERN int DeskOrderHandlingInst_MARKET_ON_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_MARKET_ON_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskOrderHandlingInst_MARKET_ON_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_MARKET_ON_CLOSE);
  return pyobj;
}


SWIGINTERN int DeskOrderHandlingInst_TIME_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_TIME_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskOrderHandlingInst_TIME_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_TIME_ORDER);
  return pyobj;
}


SWIGINTERN int DeskOrderHandlingInst_LIMIT_ON_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_LIMIT_ON_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskOrderHandlingInst_LIMIT_ON_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_LIMIT_ON_CLOSE);
  return pyobj;
}


SWIGINTERN int DeskOrderHandlingInst_IMMEDIATE_OR_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_IMMEDIATE_OR_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskOrderHandlingInst_IMMEDIATE_OR_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_IMMEDIATE_OR_CANCEL);
  return pyobj;
}


SWIGINTERN int DeskOrderHandlingInst_TRAILING_STOP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_TRAILING_STOP is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskOrderHandlingInst_TRAILING_STOP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_TRAILING_STOP);
  return pyobj;
}


SWIGINTERN int DeskOrderHandlingInst_WORK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_WORK is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskOrderHandlingInst_WORK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_WORK);
  return pyobj;
}


SWIGINTERN int DeskOrderHandlingInst_RESERVE_SIZE_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_RESERVE_SIZE_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskOrderHandlingInst_RESERVE_SIZE_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_RESERVE_SIZE_ORDER);
  return pyobj;
}


SWIGINTERN int DeskOrderHandlingInst_MINIMUM_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_MINIMUM_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskOrderHandlingInst_MINIMUM_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_MINIMUM_QUANTITY);
  return pyobj;
}


SWIGINTERN int DeskOrderHandlingInst_MARKET_AT_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_MARKET_AT_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskOrderHandlingInst_MARKET_AT_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_MARKET_AT_OPEN);
  return pyobj;
}


SWIGINTERN int DeskOrderHandlingInst_IMBALANCE_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_IMBALANCE_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskOrderHandlingInst_IMBALANCE_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_IMBALANCE_ONLY);
  return pyobj;
}


SWIGINTERN int DeskOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION);
  return pyobj;
}


SWIGINTERN int PosTransType_DO_NOT_EXERCISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosTransType_DO_NOT_EXERCISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 PosTransType_DONOTEXERCISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosTransType_DONOTEXERCISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosTransType_DONOTEXERCISE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosTransType_DONOTEXERCISE));
  return pyobj;
}


SWIGINTERN int PosTransType_LARGE_TRADER_SUBMISSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosTransType_LARGE_TRADER_SUBMISSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PosTransType_POSITIONCHANGESUBMISSIONMARGINDISPOSITION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosTransType_POSITIONCHANGESUBMISSIONMARGINDISPOSITION is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosTransType_POSITIONCHANGESUBMISSIONMARGINDISPOSITION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosTransType_POSITIONCHANGESUBMISSIONMARGINDISPOSITION));
  return pyobj;
}


SWIGINTERN int PosTransType_POSITIONADJUSTMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosTransType_POSITIONADJUSTMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosTransType_POSITIONADJUSTMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosTransType_POSITIONADJUSTMENT));
  return pyobj;
}


SWIGINTERN int PosTransType_EXERCISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosTransType_EXERCISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosTransType_EXERCISE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosTransType_EXERCISE));
  return pyobj;
}


SWIGINTERN int PosTransType_POSITION_ADJUSTMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosTransType_POSITION_ADJUSTMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosTransType_POSITION_ADJUSTMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosTransType_POSITION_ADJUSTMENT));
  return pyobj;
}


SWIGINTERN int PosTransType_PLEDGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosTransType_PLEDGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosTransType_PLEDGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosTransType_PLEDGE));
  return pyobj;
}


SWIGINTERN int Seniority_SUBORDINATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Seniority_SUBORDINATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Seniority_SUBORDINATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::Seniority_SUBORDINATED);
  return pyobj;
}


SWIGINTERN int Seniority_SENIOR_SECURED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Seniority_SENIOR_SECURED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Seniority_SENIOR_SECURED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::Seniority_SENIOR_SECURED);
  return pyobj;
}


SWIGINTERN int Seniority_SENIOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Seniority_SENIOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Seniority_SENIOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::Seniority_SENIOR);
  return pyobj;
}


SWIGINTERN int SettlCurrFxRateCalc_DIVIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlCurrFxRateCalc_DIVIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlCurrFxRateCalc_DIVIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlCurrFxRateCalc_DIVIDE));
  return pyobj;
}


SWIGINTERN int SettlCurrFxRateCalc_MULTIPLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlCurrFxRateCalc_MULTIPLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlCurrFxRateCalc_MULTIPLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlCurrFxRateCalc_MULTIPLY));
  return pyobj;
}


SWIGINTERN int PosMaintStatus_ACCEPTED_WITH_WARNINGS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintStatus_ACCEPTED_WITH_WARNINGS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PosMaintStatus_COMPLETED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintStatus_COMPLETED is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosMaintStatus_COMPLETED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintStatus_COMPLETED));
  return pyobj;
}


SWIGINTERN int PosMaintStatus_ACCEPTEDWITHWARNINGS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintStatus_ACCEPTEDWITHWARNINGS is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosMaintStatus_ACCEPTEDWITHWARNINGS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintStatus_ACCEPTEDWITHWARNINGS));
  return pyobj;
}


SWIGINTERN int PosMaintStatus_COMPLETEDWITHWARNINGS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintStatus_COMPLETEDWITHWARNINGS is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosMaintStatus_COMPLETEDWITHWARNINGS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintStatus_COMPLETEDWITHWARNINGS));
  return pyobj;
}


SWIGINTERN int PosMaintStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosMaintStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int PosMaintStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosMaintStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int PosMaintStatus_COMPLETED_WITH_WARNINGS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintStatus_COMPLETED_WITH_WARNINGS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 Benchmark_6_MO_LIBOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_6_MO_LIBOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 Benchmark_OLD_5_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_OLD_5 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Benchmark_OLD_5_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_OLD_5));
  return pyobj;
}


SWIGINTERN int Benchmark_OLD_30_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_OLD_30 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Benchmark_OLD_30_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_OLD_30));
  return pyobj;
}


SWIGINTERN int Benchmark_30YR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_30YR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Benchmark_30YR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_30YR));
  return pyobj;
}


SWIGINTERN int Benchmark_5YR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_5YR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Benchmark_5YR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_5YR));
  return pyobj;
}


SWIGINTERN int Benchmark_3_MO_LIBOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_3_MO_LIBOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 Benchmark_OLD_10_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_OLD_10 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Benchmark_OLD_10_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_OLD_10));
  return pyobj;
}


SWIGINTERN int Benchmark_6MOLIBOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_6MOLIBOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Benchmark_6MOLIBOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_6MOLIBOR));
  return pyobj;
}


SWIGINTERN int Benchmark_10YR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_10YR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Benchmark_10YR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_10YR));
  return pyobj;
}


SWIGINTERN int Benchmark_CURVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_CURVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Benchmark_CURVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_CURVE));
  return pyobj;
}


SWIGINTERN int Benchmark_30_YR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_30_YR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Benchmark_30_YR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_30_YR));
  return pyobj;
}


SWIGINTERN int Benchmark_10_YR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_10_YR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Benchmark_10_YR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_10_YR));
  return pyobj;
}


SWIGINTERN int Benchmark_5_YR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_5_YR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Benchmark_5_YR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_5_YR));
  return pyobj;
}


SWIGINTERN int Benchmark_OLD30_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_OLD30 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Benchmark_OLD30_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_OLD30));
  return pyobj;
}


SWIGINTERN int Benchmark_OLD5_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_OLD5 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Benchmark_OLD5_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_OLD5));
  return pyobj;
}


SWIGINTERN int Benchmark_OLD10_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_OLD10 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Benchmark_OLD10_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_OLD10));
  return pyobj;
}


SWIGINTERN int Benchmark_3MOLIBOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_3MOLIBOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Benchmark_3MOLIBOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_3MOLIBOR));
  return pyobj;
}


SWIGINTERN int MaturityMonthYearFormat_YEARMONTHWEEK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MaturityMonthYearFormat_YEARMONTHWEEK is read-only.");
  return 1;
}


SWIGINTERN PyObject *MaturityMonthYearFormat_YEARMONTHWEEK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearFormat_YEARMONTHWEEK));
  return pyobj;
}


SWIGINTERN int MaturityMonthYearFormat_YEARMONTHDAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MaturityMonthYearFormat_YEARMONTHDAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *MaturityMonthYearFormat_YEARMONTHDAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearFormat_YEARMONTHDAY));
  return pyobj;
}


SWIGINTERN int MaturityMonthYearFormat_YEARMONTH_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MaturityMonthYearFormat_YEARMONTH_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *MaturityMonthYearFormat_YEARMONTH_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearFormat_YEARMONTH_ONLY));
  return pyobj;
}


SWIGINTERN int LegalConfirm_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LegalConfirm_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *LegalConfirm_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LegalConfirm_NO));
  return pyobj;
}


SWIGINTERN int LegalConfirm_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LegalConfirm_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *LegalConfirm_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LegalConfirm_YES));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 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 *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 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 *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 ReportToExch_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReportToExch_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *ReportToExch_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ReportToExch_NO));
  return pyobj;
}


SWIGINTERN int ReportToExch_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReportToExch_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *ReportToExch_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ReportToExch_YES));
  return pyobj;
}


SWIGINTERN int AllocRejCode_INCORRECT_ALLOCATED_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_INCORRECT_ALLOCATED_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 AllocRejCode_UNKNOWNACCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_UNKNOWNACCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocRejCode_UNKNOWNACCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWNACCT));
  return pyobj;
}


SWIGINTERN int AllocRejCode_INCORRECTAVGPRC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_INCORRECTAVGPRC is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocRejCode_INCORRECTAVGPRC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECTAVGPRC));
  return pyobj;
}


SWIGINTERN int AllocRejCode_UNKNOWN_ORDERID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_UNKNOWN_ORDERID is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocRejCode_UNKNOWN_ORDERID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWN_ORDERID));
  return pyobj;
}


SWIGINTERN int AllocRejCode_WAREHOUSEREQUESTREJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_WAREHOUSEREQUESTREJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocRejCode_WAREHOUSEREQUESTREJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_WAREHOUSEREQUESTREJECTED));
  return pyobj;
}


SWIGINTERN int AllocRejCode_UNKNOWNORSTALEEXECID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_UNKNOWNORSTALEEXECID is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocRejCode_UNKNOWNORSTALEEXECID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWNORSTALEEXECID));
  return pyobj;
}


SWIGINTERN int AllocRejCode_WAREHOUSE_REQUEST_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_WAREHOUSE_REQUEST_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 AllocRejCode_INCORRECT_AVERAGEG_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_INCORRECT_AVERAGEG_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 AllocRejCode_MISMATCHEDDATA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_MISMATCHEDDATA is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocRejCode_MISMATCHEDDATA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_MISMATCHEDDATA));
  return pyobj;
}


SWIGINTERN int AllocRejCode_INCORRECTBRKMNC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_INCORRECTBRKMNC is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocRejCode_INCORRECTBRKMNC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECTBRKMNC));
  return pyobj;
}


SWIGINTERN int AllocRejCode_UNKNOWNLISTID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_UNKNOWNLISTID is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocRejCode_UNKNOWNLISTID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWNLISTID));
  return pyobj;
}


SWIGINTERN int AllocRejCode_OTHER_99_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_OTHER_99 is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocRejCode_OTHER_99_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_OTHER_99));
  return pyobj;
}


SWIGINTERN int AllocRejCode_INCORRECTALLOCATEDQUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_INCORRECTALLOCATEDQUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocRejCode_INCORRECTALLOCATEDQUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECTALLOCATEDQUANTITY));
  return pyobj;
}


SWIGINTERN int AllocRejCode_UNKNOWN_LISTID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_UNKNOWN_LISTID is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocRejCode_UNKNOWN_LISTID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWN_LISTID));
  return pyobj;
}


SWIGINTERN int AllocRejCode_INCORRECT_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_INCORRECT_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocRejCode_INCORRECT_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECT_QUANTITY));
  return pyobj;
}


SWIGINTERN int AllocRejCode_INCORRECT_AVERAGE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_INCORRECT_AVERAGE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 AllocRejCode_UNKNOWN_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_UNKNOWN_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocRejCode_UNKNOWN_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWN_ACCOUNT));
  return pyobj;
}


SWIGINTERN int AllocRejCode_UNKNOWN_OR_STALE_EXECID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_UNKNOWN_OR_STALE_EXECID is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 AllocRejCode_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocRejCode_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_OTHER));
  return pyobj;
}


SWIGINTERN int AllocRejCode_OTHER_7_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_OTHER_7 is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocRejCode_OTHER_7_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_OTHER_7));
  return pyobj;
}


SWIGINTERN int AllocRejCode_UNKNOWN_CLORDID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_UNKNOWN_CLORDID is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocRejCode_UNKNOWN_CLORDID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWN_CLORDID));
  return pyobj;
}


SWIGINTERN int AllocRejCode_INCORRECTQTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_INCORRECTQTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocRejCode_INCORRECTQTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECTQTY));
  return pyobj;
}


SWIGINTERN int AllocRejCode_COMMDIFF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_COMMDIFF is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocRejCode_COMMDIFF_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_COMMDIFF));
  return pyobj;
}


SWIGINTERN int AllocRejCode_CALCULATIONDIFFERENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_CALCULATIONDIFFERENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocRejCode_CALCULATIONDIFFERENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_CALCULATIONDIFFERENCE));
  return pyobj;
}


SWIGINTERN int AllocRejCode_UNKNOWNCLORDID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_UNKNOWNCLORDID is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocRejCode_UNKNOWNCLORDID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWNCLORDID));
  return pyobj;
}


SWIGINTERN int AllocRejCode_UNKNOWNORDID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_UNKNOWNORDID is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocRejCode_UNKNOWNORDID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWNORDID));
  return pyobj;
}


SWIGINTERN int AllocRejCode_MISMATCHED_DATA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_MISMATCHED_DATA is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocRejCode_MISMATCHED_DATA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_MISMATCHED_DATA));
  return pyobj;
}


SWIGINTERN int AllocRejCode_CALCULATION_DIFFERENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_CALCULATION_DIFFERENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocRejCode_CALCULATION_DIFFERENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_CALCULATION_DIFFERENCE));
  return pyobj;
}


SWIGINTERN int AllocRejCode_COMMISSION_DIFFERENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_COMMISSION_DIFFERENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocRejCode_COMMISSION_DIFFERENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_COMMISSION_DIFFERENCE));
  return pyobj;
}


SWIGINTERN int AllocRejCode_UNKNOWN_EXECUTING_BROKER_MNEMONIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_UNKNOWN_EXECUTING_BROKER_MNEMONIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 RefOrdIDReason_GTC_FROM_PREVIOUS_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrdIDReason_GTC_FROM_PREVIOUS_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 RefOrdIDReason_PARTIAL_FILL_REMAINING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrdIDReason_PARTIAL_FILL_REMAINING is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 RefOrdIDReason_ORDER_CHANGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrdIDReason_ORDER_CHANGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *RefOrdIDReason_ORDER_CHANGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RefOrdIDReason_ORDER_CHANGED));
  return pyobj;
}


SWIGINTERN int RefOrderIDSource_SECONDARYORDERID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrderIDSource_SECONDARYORDERID is read-only.");
  return 1;
}


SWIGINTERN PyObject *RefOrderIDSource_SECONDARYORDERID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_SECONDARYORDERID));
  return pyobj;
}


SWIGINTERN int RefOrderIDSource_ORDERID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrderIDSource_ORDERID is read-only.");
  return 1;
}


SWIGINTERN PyObject *RefOrderIDSource_ORDERID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_ORDERID));
  return pyobj;
}


SWIGINTERN int RefOrderIDSource_MDENTRYID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrderIDSource_MDENTRYID is read-only.");
  return 1;
}


SWIGINTERN PyObject *RefOrderIDSource_MDENTRYID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_MDENTRYID));
  return pyobj;
}


SWIGINTERN int RefOrderIDSource_ORIGINAL_ORDER_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrderIDSource_ORIGINAL_ORDER_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 RefOrderIDSource_MENTRYID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrderIDSource_MENTRYID is read-only.");
  return 1;
}


SWIGINTERN PyObject *RefOrderIDSource_MENTRYID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_MENTRYID));
  return pyobj;
}


SWIGINTERN int RefOrderIDSource_QUOTEENTRYID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrderIDSource_QUOTEENTRYID is read-only.");
  return 1;
}


SWIGINTERN PyObject *RefOrderIDSource_QUOTEENTRYID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_QUOTEENTRYID));
  return pyobj;
}


SWIGINTERN int RefOrderIDSource_QUOTENTRYID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrderIDSource_QUOTENTRYID is read-only.");
  return 1;
}


SWIGINTERN PyObject *RefOrderIDSource_QUOTENTRYID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_QUOTENTRYID));
  return pyobj;
}


SWIGINTERN int RefOrderIDSource_ORDEID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrderIDSource_ORDEID is read-only.");
  return 1;
}


SWIGINTERN PyObject *RefOrderIDSource_ORDEID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_ORDEID));
  return pyobj;
}


SWIGINTERN int RefOrderIDSource_SECONDARYORDEID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrderIDSource_SECONDARYORDEID is read-only.");
  return 1;
}


SWIGINTERN PyObject *RefOrderIDSource_SECONDARYORDEID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_SECONDARYORDEID));
  return pyobj;
}


SWIGINTERN int LastCapacity_A_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastCapacity_A is read-only.");
  return 1;
}


SWIGINTERN PyObject *LastCapacity_A_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LastCapacity_A));
  return pyobj;
}


SWIGINTERN int LastCapacity_XP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastCapacity_XP is read-only.");
  return 1;
}


SWIGINTERN PyObject *LastCapacity_XP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LastCapacity_XP));
  return pyobj;
}


SWIGINTERN int LastCapacity_CROSS_AS_PRINCIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastCapacity_CROSS_AS_PRINCIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 LastCapacity_PRINCIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastCapacity_PRINCIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *LastCapacity_PRINCIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LastCapacity_PRINCIPAL));
  return pyobj;
}


SWIGINTERN int LastCapacity_P_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastCapacity_P is read-only.");
  return 1;
}


SWIGINTERN PyObject *LastCapacity_P_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LastCapacity_P));
  return pyobj;
}


SWIGINTERN int LastCapacity_CROSS_AS_AGENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastCapacity_CROSS_AS_AGENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 LastCapacity_AGENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastCapacity_AGENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *LastCapacity_AGENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LastCapacity_AGENT));
  return pyobj;
}


SWIGINTERN int LastCapacity_XA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastCapacity_XA is read-only.");
  return 1;
}


SWIGINTERN PyObject *LastCapacity_XA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LastCapacity_XA));
  return pyobj;
}


SWIGINTERN int InstrAttribType_INSTRUMENT_STRIKE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_INSTRUMENT_STRIKE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 InstrAttribType_IN_DEFAULT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_IN_DEFAULT is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_IN_DEFAULT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_IN_DEFAULT));
  return pyobj;
}


SWIGINTERN int InstrAttribType_COUPONPERIOD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_COUPONPERIOD is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_COUPONPERIOD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_COUPONPERIOD));
  return pyobj;
}


SWIGINTERN int InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_ORIGINAL_ISSUE_DISCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 InstrAttribType_PRE_REFUNDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_PRE_REFUNDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_PRE_REFUNDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_PRE_REFUNDED));
  return pyobj;
}


SWIGINTERN int 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 *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 InstrAttribType_CALLABLEPUTTABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_CALLABLEPUTTABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_CALLABLEPUTTABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_CALLABLEPUTTABLE));
  return pyobj;
}


SWIGINTERN int InstrAttribType_WHEN_AND_IF_ISSUED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_WHEN_AND_IF_ISSUED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 InstrAttribType_STEPPEDCOUPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_STEPPEDCOUPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_STEPPEDCOUPON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_STEPPEDCOUPON));
  return pyobj;
}


SWIGINTERN int InstrAttribType_UNRATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_UNRATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_UNRATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_UNRATED));
  return pyobj;
}


SWIGINTERN int 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 *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 InstrAttribType_STEPPED_COUPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_STEPPED_COUPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_STEPPED_COUPON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_STEPPED_COUPON));
  return pyobj;
}


SWIGINTERN int InstrAttribType_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_TEXT));
  return pyobj;
}


SWIGINTERN int InstrAttribType_ORIGINALISSUEDISCOUNTPRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_ORIGINALISSUEDISCOUNTPRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_ORIGINALISSUEDISCOUNTPRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_ORIGINALISSUEDISCOUNTPRICE));
  return pyobj;
}


SWIGINTERN int InstrAttribType_ESCROWEDTOREDEMPTIONDATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_ESCROWEDTOREDEMPTIONDATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_ESCROWEDTOREDEMPTIONDATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_ESCROWEDTOREDEMPTIONDATE));
  return pyobj;
}


SWIGINTERN int InstrAttribType_INSTRUMENT_DENOMINATOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_INSTRUMENT_DENOMINATOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_INSTRUMENT_DENOMINATOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_INSTRUMENT_DENOMINATOR));
  return pyobj;
}


SWIGINTERN int InstrAttribType_ESCROWED_TO_REDEMPTION_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_ESCROWED_TO_REDEMPTION_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 InstrAttribType_INTEREST_BEARING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_INTEREST_BEARING is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_INTEREST_BEARING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_INTEREST_BEARING));
  return pyobj;
}


SWIGINTERN int InstrAttribType_TAXABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_TAXABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_TAXABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_TAXABLE));
  return pyobj;
}


SWIGINTERN int InstrAttribType_CALLABLE_PUTTABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_CALLABLE_PUTTABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_CALLABLE_PUTTABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_CALLABLE_PUTTABLE));
  return pyobj;
}


SWIGINTERN int InstrAttribType_CALLABLE_BELOW_MATURITY_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_CALLABLE_BELOW_MATURITY_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 InstrAttribType_COUPON_PERIOD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_COUPON_PERIOD is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_COUPON_PERIOD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_COUPON_PERIOD));
  return pyobj;
}


SWIGINTERN int InstrAttribType_LESSFEEFORPUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_LESSFEEFORPUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_LESSFEEFORPUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_LESSFEEFORPUT));
  return pyobj;
}


SWIGINTERN int InstrAttribType_INTERESTBEARING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_INTERESTBEARING is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_INTERESTBEARING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_INTERESTBEARING));
  return pyobj;
}


SWIGINTERN int InstrAttribType_PREREFUNDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_PREREFUNDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_PREREFUNDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_PREREFUNDED));
  return pyobj;
}


SWIGINTERN int InstrAttribType_INSTRUMENT_PRICE_PRECISION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_INSTRUMENT_PRICE_PRECISION is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 InstrAttribType_TRADEABLE_INDICATOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_TRADEABLE_INDICATOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_TRADEABLE_INDICATOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_TRADEABLE_INDICATOR));
  return pyobj;
}


SWIGINTERN int 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 *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 InstrAttribType_VARIABLE_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_VARIABLE_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_VARIABLE_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_VARIABLE_RATE));
  return pyobj;
}


SWIGINTERN int InstrAttribType_WHENISSUED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_WHENISSUED is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_WHENISSUED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_WHENISSUED));
  return pyobj;
}


SWIGINTERN int InstrAttribType_ZEROCOUPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_ZEROCOUPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_ZEROCOUPON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_ZEROCOUPON));
  return pyobj;
}


SWIGINTERN int InstrAttribType_SUBJECTTOALTERNATIVEMINIMUMTAX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_SUBJECTTOALTERNATIVEMINIMUMTAX is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_SUBJECTTOALTERNATIVEMINIMUMTAX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_SUBJECTTOALTERNATIVEMINIMUMTAX));
  return pyobj;
}


SWIGINTERN int InstrAttribType_ESCROWEDTOMATURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_ESCROWEDTOMATURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_ESCROWEDTOMATURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_ESCROWEDTOMATURITY));
  return pyobj;
}


SWIGINTERN int InstrAttribType_FLAT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_FLAT is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_FLAT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_FLAT));
  return pyobj;
}


SWIGINTERN int 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 *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 InstrAttribType_INSTRUMENT_NUMERATOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_INSTRUMENT_NUMERATOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_INSTRUMENT_NUMERATOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_INSTRUMENT_NUMERATOR));
  return pyobj;
}


SWIGINTERN int InstrAttribType_ESCROWED_TO_MATURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_ESCROWED_TO_MATURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 InstrAttribType_LESS_FEE_FOR_PUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_LESS_FEE_FOR_PUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 InstrAttribType_CALLABLEWITHOUTNOTICEBYMAILTOHOLDERUNLESSREGISTERED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_CALLABLEWITHOUTNOTICEBYMAILTOHOLDERUNLESSREGISTERED is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_CALLABLEWITHOUTNOTICEBYMAILTOHOLDERUNLESSREGISTERED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_CALLABLEWITHOUTNOTICEBYMAILTOHOLDERUNLESSREGISTERED));
  return pyobj;
}


SWIGINTERN int InstrAttribType_INDEXED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_INDEXED is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_INDEXED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_INDEXED));
  return pyobj;
}


SWIGINTERN int InstrAttribType_INDEFAULT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_INDEFAULT is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_INDEFAULT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_INDEFAULT));
  return pyobj;
}


SWIGINTERN int InstrAttribType_ZERO_COUPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_ZERO_COUPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_ZERO_COUPON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_ZERO_COUPON));
  return pyobj;
}


SWIGINTERN int InstrAttribType_NOPERIODICPAYMENTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_NOPERIODICPAYMENTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_NOPERIODICPAYMENTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_NOPERIODICPAYMENTS));
  return pyobj;
}


SWIGINTERN int InstrAttribType_CALLABLEBELOWMATURITYVALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_CALLABLEBELOWMATURITYVALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_CALLABLEBELOWMATURITYVALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_CALLABLEBELOWMATURITYVALUE));
  return pyobj;
}


SWIGINTERN int InstrAttribType_ORIGINALISSUEDISCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_ORIGINALISSUEDISCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_ORIGINALISSUEDISCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_ORIGINALISSUEDISCOUNT));
  return pyobj;
}


SWIGINTERN int 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 *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 InstrAttribType_NO_PERIODIC_PAYMENTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_NO_PERIODIC_PAYMENTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 InstrAttribType_VARIABLERATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_VARIABLERATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *InstrAttribType_VARIABLERATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_VARIABLERATE));
  return pyobj;
}


SWIGINTERN int Product_FINANCING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_FINANCING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Product_FINANCING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_FINANCING));
  return pyobj;
}


SWIGINTERN int Product_COMMODITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_COMMODITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Product_COMMODITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_COMMODITY));
  return pyobj;
}


SWIGINTERN int Product_EQUITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_EQUITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Product_EQUITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_EQUITY));
  return pyobj;
}


SWIGINTERN int Product_CORPORATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_CORPORATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Product_CORPORATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_CORPORATE));
  return pyobj;
}


SWIGINTERN int Product_AGENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_AGENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Product_AGENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_AGENCY));
  return pyobj;
}


SWIGINTERN int Product_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Product_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_OTHER));
  return pyobj;
}


SWIGINTERN int Product_MONEYMARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_MONEYMARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Product_MONEYMARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_MONEYMARKET));
  return pyobj;
}


SWIGINTERN int Product_MORTGAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_MORTGAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Product_MORTGAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_MORTGAGE));
  return pyobj;
}


SWIGINTERN int Product_CURRENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_CURRENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Product_CURRENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_CURRENCY));
  return pyobj;
}


SWIGINTERN int Product_INDEX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_INDEX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Product_INDEX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_INDEX));
  return pyobj;
}


SWIGINTERN int Product_MUNICIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_MUNICIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Product_MUNICIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_MUNICIPAL));
  return pyobj;
}


SWIGINTERN int Product_LOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_LOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Product_LOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_LOAN));
  return pyobj;
}


SWIGINTERN int Product_GOVERNMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_GOVERNMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Product_GOVERNMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_GOVERNMENT));
  return pyobj;
}


SWIGINTERN int SecurityTradingStatus_NOMKTIMB_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_NOMKTIMB is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_NOMKTIMB_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NOMKTIMB));
  return pyobj;
}


SWIGINTERN int SecurityTradingStatus_NOOPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_NOOPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_NOOPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NOOPEN));
  return pyobj;
}


SWIGINTERN int SecurityTradingStatus_FAST_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_FAST_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_FAST_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_FAST_MARKET));
  return pyobj;
}


SWIGINTERN int SecurityTradingStatus_NO_OPEN_NO_RESUME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_NO_OPEN_NO_RESUME is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SecurityTradingStatus_TRADING_HALT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_TRADING_HALT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_TRADING_HALT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_TRADING_HALT));
  return pyobj;
}


SWIGINTERN int SecurityTradingStatus_NOT_AVAILABLE_FOR_TRADING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_NOT_AVAILABLE_FOR_TRADING is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SecurityTradingStatus_11_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_11 is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_11_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_11));
  return pyobj;
}


SWIGINTERN int SecurityTradingStatus_NO_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_NO_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_NO_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NO_OPEN));
  return pyobj;
}


SWIGINTERN int SecurityTradingStatus_NOTTRADED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_NOTTRADED is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_NOTTRADED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NOTTRADED));
  return pyobj;
}


SWIGINTERN int SecurityTradingStatus_FASTMARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_FASTMARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_FASTMARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_FASTMARKET));
  return pyobj;
}


SWIGINTERN int SecurityTradingStatus_MKTBALSELL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_MKTBALSELL is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_MKTBALSELL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_MKTBALSELL));
  return pyobj;
}


SWIGINTERN int SecurityTradingStatus_NEWPXIND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_NEWPXIND is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_NEWPXIND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NEWPXIND));
  return pyobj;
}


SWIGINTERN int SecurityTradingStatus_TRDDISTIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_TRDDISTIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_TRDDISTIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_TRDDISTIME));
  return pyobj;
}


SWIGINTERN int SecurityTradingStatus_PXIND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_PXIND is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_PXIND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_PXIND));
  return pyobj;
}


SWIGINTERN int SecurityTradingStatus_CROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_CROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_CROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_CROSS));
  return pyobj;
}


SWIGINTERN int SecurityTradingStatus_OPENINGROTATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_OPENINGROTATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_OPENINGROTATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_OPENINGROTATION));
  return pyobj;
}


SWIGINTERN int SecurityTradingStatus_TRDRNGIND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_TRDRNGIND is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_TRDRNGIND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_TRDRNGIND));
  return pyobj;
}


SWIGINTERN int SecurityTradingStatus_RESUME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_RESUME is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_RESUME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_RESUME));
  return pyobj;
}


SWIGINTERN int SecurityTradingStatus_TRADE_DISSEMINATION_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_TRADE_DISSEMINATION_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 SecurityTradingStatus_POST_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_POST_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_POST_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_POST_CLOSE));
  return pyobj;
}


SWIGINTERN int SecurityTradingStatus_OPENDELAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_OPENDELAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_OPENDELAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_OPENDELAY));
  return pyobj;
}


SWIGINTERN int SecurityTradingStatus_READY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_READY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_READY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_READY));
  return pyobj;
}


SWIGINTERN int 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 *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 SecurityTradingStatus_NOTAVAIL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_NOTAVAIL is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_NOTAVAIL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NOTAVAIL));
  return pyobj;
}


SWIGINTERN int SecurityTradingStatus_MARKET_IMBALANCE_SELL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_MARKET_IMBALANCE_SELL is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SecurityTradingStatus_OPENING_DELAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_OPENING_DELAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_OPENING_DELAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_OPENING_DELAY));
  return pyobj;
}


SWIGINTERN int SecurityTradingStatus_MKTONCLSIMBSELL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_MKTONCLSIMBSELL is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_MKTONCLSIMBSELL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_MKTONCLSIMBSELL));
  return pyobj;
}


SWIGINTERN int 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 *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 SecurityTradingStatus_ITS_PRE_OPENING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_ITS_PRE_OPENING is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SecurityTradingStatus_PRE_CROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_PRE_CROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_PRE_CROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_PRE_CROSS));
  return pyobj;
}


SWIGINTERN int SecurityTradingStatus_NA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_NA is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_NA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NA));
  return pyobj;
}


SWIGINTERN int SecurityTradingStatus_NOMKTONCLSIMB_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_NOMKTONCLSIMB is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_NOMKTONCLSIMB_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NOMKTONCLSIMB));
  return pyobj;
}


SWIGINTERN int SecurityTradingStatus_PRE_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_PRE_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_PRE_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_PRE_OPEN));
  return pyobj;
}


SWIGINTERN int SecurityTradingStatus_MARKET_IMBALANCE_BUY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_MARKET_IMBALANCE_BUY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SecurityTradingStatus_TRADING_RANGE_INDICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_TRADING_RANGE_INDICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SecurityTradingStatus_READY_TO_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_READY_TO_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SecurityTradingStatus_NEW_PRICE_INDICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_NEW_PRICE_INDICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 SecurityTradingStatus_ITSPREOPN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_ITSPREOPN is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_ITSPREOPN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_ITSPREOPN));
  return pyobj;
}


SWIGINTERN int SecurityTradingStatus_TRDHALT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_TRDHALT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_TRDHALT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_TRDHALT));
  return pyobj;
}


SWIGINTERN int SecurityTradingStatus_MKTONCLSIMBBUY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_MKTONCLSIMBBUY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_MKTONCLSIMBBUY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_MKTONCLSIMBBUY));
  return pyobj;
}


SWIGINTERN int SecurityTradingStatus_OPENING_ROTATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_OPENING_ROTATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_OPENING_ROTATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_OPENING_ROTATION));
  return pyobj;
}


SWIGINTERN int SecurityTradingStatus_PRICE_INDICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_PRICE_INDICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_PRICE_INDICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_PRICE_INDICATION));
  return pyobj;
}


SWIGINTERN int SecurityTradingStatus_UNKNOWN_OR_INVALID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_UNKNOWN_OR_INVALID is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 SecurityTradingStatus_UNKNOWN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_UNKNOWN is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_UNKNOWN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_UNKNOWN));
  return pyobj;
}


SWIGINTERN int SecurityTradingStatus_MKTIMBBUY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_MKTIMBBUY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SecurityTradingStatus_MKTIMBBUY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_MKTIMBBUY));
  return pyobj;
}


SWIGINTERN int SecurityTradingStatus_NO_MARKET_IMBALANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_NO_MARKET_IMBALANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 Rule80A_PRGINDEXARBOTHMEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_PRGINDEXARBOTHMEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Rule80A_PRGINDEXARBOTHMEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_PRGINDEXARBOTHMEM));
  return pyobj;
}


SWIGINTERN int 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 *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 Rule80A_SPECIALIST_TRADES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_SPECIALIST_TRADES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Rule80A_SPECIALIST_TRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_SPECIALIST_TRADES));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 Rule80A_SHTEXTRANI_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_SHTEXTRANI is read-only.");
  return 1;
}


SWIGINTERN PyObject *Rule80A_SHTEXTRANI_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHTEXTRANI));
  return pyobj;
}


SWIGINTERN int Rule80A_SHTEXTRANMEMWT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_SHTEXTRANMEMWT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Rule80A_SHTEXTRANMEMWT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHTEXTRANMEMWT));
  return pyobj;
}


SWIGINTERN int Rule80A_SHORT_EXEMPT_TRANSACTION_F_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_SHORT_EXEMPT_TRANSACTION_F is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 Rule80A_COMPETING_DEALER_TRADES_O_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_COMPETING_DEALER_TRADES_O is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 Rule80A_AGENCY_ALGORITHMIC_PROGRAM_TRADING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_AGENCY_ALGORITHMIC_PROGRAM_TRADING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Rule80A_AGENCY_ALGORITHMIC_PROGRAM_TRADING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_AGENCY_ALGORITHMIC_PROGRAM_TRADING));
  return pyobj;
}


SWIGINTERN int Rule80A_SHTEXTRANMEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_SHTEXTRANMEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Rule80A_SHTEXTRANMEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHTEXTRANMEM));
  return pyobj;
}


SWIGINTERN int Rule80A_PRGINDEXARBOTHAGN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_PRGINDEXARBOTHAGN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Rule80A_PRGINDEXARBOTHAGN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_PRGINDEXARBOTHAGN));
  return pyobj;
}


SWIGINTERN int Rule80A_PRGNONINDEXARBINV_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_PRGNONINDEXARBINV is read-only.");
  return 1;
}


SWIGINTERN PyObject *Rule80A_PRGNONINDEXARBINV_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_PRGNONINDEXARBINV));
  return pyobj;
}


SWIGINTERN int Rule80A_SHORT_EXEMPT_TRANSACTION_H_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_SHORT_EXEMPT_TRANSACTION_H is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 Rule80A_PRINCIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_PRINCIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Rule80A_PRINCIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_PRINCIPAL));
  return pyobj;
}


SWIGINTERN int Rule80A_AGENCY_INDEX_ARBITRAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_AGENCY_INDEX_ARBITRAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Rule80A_AGENCY_INDEX_ARBITRAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_AGENCY_INDEX_ARBITRAGE));
  return pyobj;
}


SWIGINTERN int Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_A_NON_MEMBER_COMPTING_MARKET_MAKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_A_NON_MEMBER_COMPTING_MARKET_MAKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_A_NON_MEMBER_COMPTING_MARKET_MAKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_A_NON_MEMBER_COMPTING_MARKET_MAKER));
  return pyobj;
}


SWIGINTERN int Rule80A_SHTEXTRANA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_SHTEXTRANA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Rule80A_SHTEXTRANA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHTEXTRANA));
  return pyobj;
}


SWIGINTERN int Rule80A_SHTEXTRANW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_SHTEXTRANW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Rule80A_SHTEXTRANW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHTEXTRANW));
  return pyobj;
}


SWIGINTERN int Rule80A_PRGINDEXARBINV_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_PRGINDEXARBINV is read-only.");
  return 1;
}


SWIGINTERN PyObject *Rule80A_PRGINDEXARBINV_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_PRGINDEXARBINV));
  return pyobj;
}


SWIGINTERN int Rule80A_COMPETING_DEALER_TRADES_R_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_COMPETING_DEALER_TRADES_R is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 Rule80A_INDIVIDUAL_INVESTOR_SINGLE_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_INDIVIDUAL_INVESTOR_SINGLE_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 Rule80A_PROPRIETARY_NON_ALGORITHMIC_PROGRAM_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_PROPRIETARY_NON_ALGORITHMIC_PROGRAM_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Rule80A_PROPRIETARY_NON_ALGORITHMIC_PROGRAM_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_PROPRIETARY_NON_ALGORITHMIC_PROGRAM_TRADE));
  return pyobj;
}


SWIGINTERN int Rule80A_AGENT_FOR_OTHER_MEMBER_NON_ALGORITHMIC_PROGRAM_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_AGENT_FOR_OTHER_MEMBER_NON_ALGORITHMIC_PROGRAM_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Rule80A_AGENT_FOR_OTHER_MEMBER_NON_ALGORITHMIC_PROGRAM_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_AGENT_FOR_OTHER_MEMBER_NON_ALGORITHMIC_PROGRAM_TRADE));
  return pyobj;
}


SWIGINTERN int Rule80A_ALLOTHERAGN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_ALLOTHERAGN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Rule80A_ALLOTHERAGN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_ALLOTHERAGN));
  return pyobj;
}


SWIGINTERN int Rule80A_PRGNONINDEXARBOTHAGN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_PRGNONINDEXARBOTHAGN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Rule80A_PRGNONINDEXARBOTHAGN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_PRGNONINDEXARBOTHAGN));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 Rule80A_AGENCYSINGLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_AGENCYSINGLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Rule80A_AGENCYSINGLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_AGENCYSINGLE));
  return pyobj;
}


SWIGINTERN int Rule80A_COMPETING_DEALER_TRADES_T_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_COMPETING_DEALER_TRADES_T is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 Rule80A_PROPRIETARY_ALGORITHMIC_PROGRAM_TRADING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_PROPRIETARY_ALGORITHMIC_PROGRAM_TRADING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Rule80A_PROPRIETARY_ALGORITHMIC_PROGRAM_TRADING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_PROPRIETARY_ALGORITHMIC_PROGRAM_TRADING));
  return pyobj;
}


SWIGINTERN int Rule80A_AGENCY_NON_ALGORITHMIC_PROGRAM_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_AGENCY_NON_ALGORITHMIC_PROGRAM_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Rule80A_AGENCY_NON_ALGORITHMIC_PROGRAM_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_AGENCY_NON_ALGORITHMIC_PROGRAM_TRADE));
  return pyobj;
}


SWIGINTERN int Rule80A_PRGNONINDEXARBMEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_PRGNONINDEXARBMEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Rule80A_PRGNONINDEXARBMEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_PRGNONINDEXARBMEM));
  return pyobj;
}


SWIGINTERN int Rule80A_PRGNONINDEXARBOTHMEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_PRGNONINDEXARBOTHMEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Rule80A_PRGNONINDEXARBOTHMEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_PRGNONINDEXARBOTHMEM));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 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 *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 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 *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 Rule80A_PRGINDEXARBMEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_PRGINDEXARBMEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Rule80A_PRGINDEXARBMEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_PRGINDEXARBMEM));
  return pyobj;
}


SWIGINTERN int Rule80A_INVINESTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_INVINESTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Rule80A_INVINESTOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_INVINESTOR));
  return pyobj;
}


SWIGINTERN int 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 *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 Rule80A_SHORT_EXEMPT_TRANSACTION_B_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_SHORT_EXEMPT_TRANSACTION_B is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 Rule80A_AGENCY_SINGLE_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_AGENCY_SINGLE_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_AFFLIATED_WITH_THE_FIRM_CLEARING_THE_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_AFFLIATED_WITH_THE_FIRM_CLEARING_THE_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_AFFLIATED_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_AFFLIATED_WITH_THE_FIRM_CLEARING_THE_TRADE));
  return pyobj;
}


SWIGINTERN int Rule80A_COMPETINGDEALER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_COMPETINGDEALER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Rule80A_COMPETINGDEALER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_COMPETINGDEALER));
  return pyobj;
}


SWIGINTERN int Rule80A_COMPDEALER1_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_COMPDEALER1 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Rule80A_COMPDEALER1_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_COMPDEALER1));
  return pyobj;
}


SWIGINTERN int Rule80A_SHTEXTRANNONMEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_SHTEXTRANNONMEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Rule80A_SHTEXTRANNONMEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHTEXTRANNONMEM));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 Rule80A_MARKETMAKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_MARKETMAKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Rule80A_MARKETMAKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_MARKETMAKER));
  return pyobj;
}


SWIGINTERN int Rule80A_SPECIALIST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_SPECIALIST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Rule80A_SPECIALIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_SPECIALIST));
  return pyobj;
}


SWIGINTERN int Rule80A_COMPDEALER2_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_COMPDEALER2 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Rule80A_COMPDEALER2_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_COMPDEALER2));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 CorporateAction_MERGER_REORGANIZATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_MERGER_REORGANIZATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *CorporateAction_MERGER_REORGANIZATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_MERGER_REORGANIZATION));
  return pyobj;
}


SWIGINTERN int CorporateAction_SYMBOL_CONVERSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_SYMBOL_CONVERSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *CorporateAction_SYMBOL_CONVERSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_SYMBOL_CONVERSION));
  return pyobj;
}


SWIGINTERN int CorporateAction_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *CorporateAction_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_NEW));
  return pyobj;
}


SWIGINTERN int CorporateAction_SUCCESSION_EVENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_SUCCESSION_EVENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *CorporateAction_SUCCESSION_EVENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_SUCCESSION_EVENT));
  return pyobj;
}


SWIGINTERN int CorporateAction_STOCK_DIVIDEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_STOCK_DIVIDEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *CorporateAction_STOCK_DIVIDEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_STOCK_DIVIDEND));
  return pyobj;
}


SWIGINTERN int CorporateAction_REVERSE_STOCK_SPLIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_REVERSE_STOCK_SPLIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 CorporateAction_POSITION_CONSOLIDATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_POSITION_CONSOLIDATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *CorporateAction_POSITION_CONSOLIDATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_POSITION_CONSOLIDATION));
  return pyobj;
}


SWIGINTERN int CorporateAction_SPINOFF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_SPINOFF is read-only.");
  return 1;
}


SWIGINTERN PyObject *CorporateAction_SPINOFF_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_SPINOFF));
  return pyobj;
}


SWIGINTERN int CorporateAction_EXDIVIDEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_EXDIVIDEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *CorporateAction_EXDIVIDEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_EXDIVIDEND));
  return pyobj;
}


SWIGINTERN int CorporateAction_EX_INTEREST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_EX_INTEREST is read-only.");
  return 1;
}


SWIGINTERN PyObject *CorporateAction_EX_INTEREST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_EX_INTEREST));
  return pyobj;
}


SWIGINTERN int CorporateAction_LIQUIDATION_REORGANIZATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_LIQUIDATION_REORGANIZATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *CorporateAction_LIQUIDATION_REORGANIZATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_LIQUIDATION_REORGANIZATION));
  return pyobj;
}


SWIGINTERN int CorporateAction_CASH_DIVIDEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_CASH_DIVIDEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *CorporateAction_CASH_DIVIDEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_CASH_DIVIDEND));
  return pyobj;
}


SWIGINTERN int CorporateAction_STANDARD_INTEGER_STOCK_SPLIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_STANDARD_INTEGER_STOCK_SPLIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 CorporateAction_RIGHTS_OFFERING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_RIGHTS_OFFERING is read-only.");
  return 1;
}


SWIGINTERN PyObject *CorporateAction_RIGHTS_OFFERING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_RIGHTS_OFFERING));
  return pyobj;
}


SWIGINTERN int CorporateAction_SHAREHOLDER_MEETING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_SHAREHOLDER_MEETING is read-only.");
  return 1;
}


SWIGINTERN PyObject *CorporateAction_SHAREHOLDER_MEETING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_SHAREHOLDER_MEETING));
  return pyobj;
}


SWIGINTERN int CorporateAction_WARRANT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_WARRANT is read-only.");
  return 1;
}


SWIGINTERN PyObject *CorporateAction_WARRANT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_WARRANT));
  return pyobj;
}


SWIGINTERN int CorporateAction_EXDIST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_EXDIST is read-only.");
  return 1;
}


SWIGINTERN PyObject *CorporateAction_EXDIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_EXDIST));
  return pyobj;
}


SWIGINTERN int CorporateAction_EX_RIGHTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_EX_RIGHTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *CorporateAction_EX_RIGHTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_EX_RIGHTS));
  return pyobj;
}


SWIGINTERN int CorporateAction_EX_DISTRIBUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_EX_DISTRIBUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *CorporateAction_EX_DISTRIBUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_EX_DISTRIBUTION));
  return pyobj;
}


SWIGINTERN int CorporateAction_EX_DIVIDEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_EX_DIVIDEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *CorporateAction_EX_DIVIDEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_EX_DIVIDEND));
  return pyobj;
}


SWIGINTERN int CorporateAction_TENDER_OFFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_TENDER_OFFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *CorporateAction_TENDER_OFFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_TENDER_OFFER));
  return pyobj;
}


SWIGINTERN int CorporateAction_SPECIAL_ACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_SPECIAL_ACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *CorporateAction_SPECIAL_ACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_SPECIAL_ACTION));
  return pyobj;
}


SWIGINTERN int CorporateAction_EXINTEREST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_EXINTEREST is read-only.");
  return 1;
}


SWIGINTERN PyObject *CorporateAction_EXINTEREST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_EXINTEREST));
  return pyobj;
}


SWIGINTERN int CorporateAction_NON_INTEGER_STOCK_SPLIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_NON_INTEGER_STOCK_SPLIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 CorporateAction_CUSIP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_CUSIP is read-only.");
  return 1;
}


SWIGINTERN PyObject *CorporateAction_CUSIP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_CUSIP));
  return pyobj;
}


SWIGINTERN int CorporateAction_LEAP_ROLLOVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_LEAP_ROLLOVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *CorporateAction_LEAP_ROLLOVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_LEAP_ROLLOVER));
  return pyobj;
}


SWIGINTERN int CorporateAction_EXRIGHTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_EXRIGHTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *CorporateAction_EXRIGHTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_EXRIGHTS));
  return pyobj;
}


SWIGINTERN int TerminationType_TERM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TerminationType_TERM is read-only.");
  return 1;
}


SWIGINTERN PyObject *TerminationType_TERM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TerminationType_TERM));
  return pyobj;
}


SWIGINTERN int TerminationType_FLEXIBLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TerminationType_FLEXIBLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *TerminationType_FLEXIBLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TerminationType_FLEXIBLE));
  return pyobj;
}


SWIGINTERN int TerminationType_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TerminationType_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *TerminationType_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TerminationType_OPEN));
  return pyobj;
}


SWIGINTERN int TerminationType_OVERNIGHT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TerminationType_OVERNIGHT is read-only.");
  return 1;
}


SWIGINTERN PyObject *TerminationType_OVERNIGHT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TerminationType_OVERNIGHT));
  return pyobj;
}


SWIGINTERN int PosMaintAction_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintAction_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosMaintAction_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintAction_REPLACE));
  return pyobj;
}


SWIGINTERN int PosMaintAction_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintAction_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosMaintAction_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintAction_NEW));
  return pyobj;
}


SWIGINTERN int PosMaintAction_REVERSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintAction_REVERSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosMaintAction_REVERSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintAction_REVERSE));
  return pyobj;
}


SWIGINTERN int PosMaintAction_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintAction_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosMaintAction_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintAction_CANCEL));
  return pyobj;
}


SWIGINTERN int ComplexEventPriceTimeType_SPECIFIED_DATE_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPriceTimeType_SPECIFIED_DATE_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ComplexEventPriceTimeType_EXPIRATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPriceTimeType_EXPIRATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *ComplexEventPriceTimeType_EXPIRATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceTimeType_EXPIRATION));
  return pyobj;
}


SWIGINTERN int ComplexEventPriceTimeType_IMMEDIATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPriceTimeType_IMMEDIATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ComplexEventPriceTimeType_IMMEDIATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceTimeType_IMMEDIATE));
  return pyobj;
}


SWIGINTERN int UnderlyingFXRateCalc_DIVIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingFXRateCalc_DIVIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *UnderlyingFXRateCalc_DIVIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::UnderlyingFXRateCalc_DIVIDE));
  return pyobj;
}


SWIGINTERN int UnderlyingFXRateCalc_MULTIPLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingFXRateCalc_MULTIPLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *UnderlyingFXRateCalc_MULTIPLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::UnderlyingFXRateCalc_MULTIPLY));
  return pyobj;
}


SWIGINTERN int OddLot_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OddLot_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *OddLot_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OddLot_NO));
  return pyobj;
}


SWIGINTERN int OddLot_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OddLot_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *OddLot_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OddLot_YES));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 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 *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 AllocStatus_REJECTED_BY_INTERMEDIARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_REJECTED_BY_INTERMEDIARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 AllocStatus_ACCEPTEDSUCCESSFULLYPROCESSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_ACCEPTEDSUCCESSFULLYPROCESSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocStatus_ACCEPTEDSUCCESSFULLYPROCESSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_ACCEPTEDSUCCESSFULLYPROCESSED));
  return pyobj;
}


SWIGINTERN int AllocStatus_ACCOUNTLEVELREJECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_ACCOUNTLEVELREJECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocStatus_ACCOUNTLEVELREJECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_ACCOUNTLEVELREJECT));
  return pyobj;
}


SWIGINTERN int AllocStatus_BLOCK_LEVEL_REJECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_BLOCK_LEVEL_REJECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 AllocStatus_ACCOUNT_LEVEL_REJECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_ACCOUNT_LEVEL_REJECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 AllocStatus_INCOMPLETE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_INCOMPLETE is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocStatus_INCOMPLETE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_INCOMPLETE));
  return pyobj;
}


SWIGINTERN int AllocStatus_ALLOCATION_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_ALLOCATION_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocStatus_ALLOCATION_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_ALLOCATION_PENDING));
  return pyobj;
}


SWIGINTERN int AllocStatus_BLOCKLEVELREJECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_BLOCKLEVELREJECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocStatus_BLOCKLEVELREJECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_BLOCKLEVELREJECT));
  return pyobj;
}


SWIGINTERN int AllocStatus_REJECTEDBYINTERMEDIARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_REJECTEDBYINTERMEDIARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocStatus_REJECTEDBYINTERMEDIARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_REJECTEDBYINTERMEDIARY));
  return pyobj;
}


SWIGINTERN int AllocStatus_RECEIVEDRECEIVEDNOTYETPROCESSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_RECEIVEDRECEIVEDNOTYETPROCESSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocStatus_RECEIVEDRECEIVEDNOTYETPROCESSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_RECEIVEDRECEIVEDNOTYETPROCESSED));
  return pyobj;
}


SWIGINTERN int AllocStatus_REVERSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_REVERSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocStatus_REVERSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_REVERSED));
  return pyobj;
}


SWIGINTERN int AllocStatus_RECEIVED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_RECEIVED is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocStatus_RECEIVED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_RECEIVED));
  return pyobj;
}


SWIGINTERN int AllocStatus_PARTIAL_ACCEPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_PARTIAL_ACCEPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocStatus_PARTIAL_ACCEPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_PARTIAL_ACCEPT));
  return pyobj;
}


SWIGINTERN int AllocStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int AllocStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *AllocStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int IncTaxInd_NET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IncTaxInd_NET is read-only.");
  return 1;
}


SWIGINTERN PyObject *IncTaxInd_NET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::IncTaxInd_NET));
  return pyobj;
}


SWIGINTERN int IncTaxInd_GROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IncTaxInd_GROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *IncTaxInd_GROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::IncTaxInd_GROSS));
  return pyobj;
}


SWIGINTERN int PartyListResponseType_RETURN_ONLY_PARTY_INFORMATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyListResponseType_RETURN_ONLY_PARTY_INFORMATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyListResponseType_RETURN_ONLY_PARTY_INFORMATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyListResponseType_RETURN_ONLY_PARTY_INFORMATION));
  return pyobj;
}


SWIGINTERN int PartyListResponseType_RETURN_ALL_AVAILABLE_INFORMATION_ON_PARTIES_AND_RELATED_PARTIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyListResponseType_RETURN_ALL_AVAILABLE_INFORMATION_ON_PARTIES_AND_RELATED_PARTIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyListResponseType_RETURN_ALL_AVAILABLE_INFORMATION_ON_PARTIES_AND_RELATED_PARTIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyListResponseType_RETURN_ALL_AVAILABLE_INFORMATION_ON_PARTIES_AND_RELATED_PARTIES));
  return pyobj;
}


SWIGINTERN int PartyListResponseType_INCLUDE_RISK_LIMIT_INFORMATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyListResponseType_INCLUDE_RISK_LIMIT_INFORMATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyListResponseType_INCLUDE_RISK_LIMIT_INFORMATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyListResponseType_INCLUDE_RISK_LIMIT_INFORMATION));
  return pyobj;
}


SWIGINTERN int PartyListResponseType_INCLUDE_INFORMATION_ON_RELATED_PARTIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyListResponseType_INCLUDE_INFORMATION_ON_RELATED_PARTIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyListResponseType_INCLUDE_INFORMATION_ON_RELATED_PARTIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyListResponseType_INCLUDE_INFORMATION_ON_RELATED_PARTIES));
  return pyobj;
}


SWIGINTERN int PosReqStatus_COMPLETED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqStatus_COMPLETED is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosReqStatus_COMPLETED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqStatus_COMPLETED));
  return pyobj;
}


SWIGINTERN int PosReqStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosReqStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int PosReqStatus_COMPLETEDWITHWARNINGS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqStatus_COMPLETEDWITHWARNINGS is read-only.");
  return 1;
}


SWIGINTERN PyObject *PosReqStatus_COMPLETEDWITHWARNINGS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqStatus_COMPLETEDWITHWARNINGS));
  return pyobj;
}


SWIGINTERN int PosReqStatus_COMPLETED_WITH_WARNINGS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqStatus_COMPLETED_WITH_WARNINGS is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 PriorityIndicator_PRIORITY_UNCHANGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriorityIndicator_PRIORITY_UNCHANGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *PriorityIndicator_PRIORITY_UNCHANGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriorityIndicator_PRIORITY_UNCHANGED));
  return pyobj;
}


SWIGINTERN int PriorityIndicator_PRIORITYUNCHANGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriorityIndicator_PRIORITYUNCHANGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *PriorityIndicator_PRIORITYUNCHANGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriorityIndicator_PRIORITYUNCHANGED));
  return pyobj;
}


SWIGINTERN int PriorityIndicator_LOSTPRIORITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriorityIndicator_LOSTPRIORITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PriorityIndicator_LOSTPRIORITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriorityIndicator_LOSTPRIORITY));
  return pyobj;
}


SWIGINTERN int 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 *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 MoneyLaunderingStatus_NOTCHECKED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MoneyLaunderingStatus_NOTCHECKED is read-only.");
  return 1;
}


SWIGINTERN PyObject *MoneyLaunderingStatus_NOTCHECKED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_NOTCHECKED));
  return pyobj;
}


SWIGINTERN int MoneyLaunderingStatus_EXEMPT_BELOW_THE_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MoneyLaunderingStatus_EXEMPT_BELOW_THE_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 MoneyLaunderingStatus_EXAUTHCREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MoneyLaunderingStatus_EXAUTHCREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *MoneyLaunderingStatus_EXAUTHCREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_EXAUTHCREDIT));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 MoneyLaunderingStatus_NOT_CHECKED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MoneyLaunderingStatus_NOT_CHECKED is read-only.");
  return 1;
}


SWIGINTERN PyObject *MoneyLaunderingStatus_NOT_CHECKED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_NOT_CHECKED));
  return pyobj;
}


SWIGINTERN int MoneyLaunderingStatus_PASSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MoneyLaunderingStatus_PASSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *MoneyLaunderingStatus_PASSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_PASSED));
  return pyobj;
}


SWIGINTERN int MoneyLaunderingStatus_EXEMPT_1_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MoneyLaunderingStatus_EXEMPT_1 is read-only.");
  return 1;
}


SWIGINTERN PyObject *MoneyLaunderingStatus_EXEMPT_1_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_EXEMPT_1));
  return pyobj;
}


SWIGINTERN int MoneyLaunderingStatus_EXCLIENTMONEYTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MoneyLaunderingStatus_EXCLIENTMONEYTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MoneyLaunderingStatus_EXCLIENTMONEYTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_EXCLIENTMONEYTYPE));
  return pyobj;
}


SWIGINTERN int MoneyLaunderingStatus_EXEMPT_2_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MoneyLaunderingStatus_EXEMPT_2 is read-only.");
  return 1;
}


SWIGINTERN PyObject *MoneyLaunderingStatus_EXEMPT_2_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_EXEMPT_2));
  return pyobj;
}


SWIGINTERN int MoneyLaunderingStatus_EXBELOWLIM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MoneyLaunderingStatus_EXBELOWLIM is read-only.");
  return 1;
}


SWIGINTERN PyObject *MoneyLaunderingStatus_EXBELOWLIM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_EXBELOWLIM));
  return pyobj;
}


SWIGINTERN int MoneyLaunderingStatus_EXEMPT_3_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MoneyLaunderingStatus_EXEMPT_3 is read-only.");
  return 1;
}


SWIGINTERN PyObject *MoneyLaunderingStatus_EXEMPT_3_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_EXEMPT_3));
  return pyobj;
}


SWIGINTERN int 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 *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 LotType_ROUND_LOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LotType_ROUND_LOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *LotType_ROUND_LOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LotType_ROUND_LOT));
  return pyobj;
}


SWIGINTERN int LotType_ODD_LOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LotType_ODD_LOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *LotType_ODD_LOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LotType_ODD_LOT));
  return pyobj;
}


SWIGINTERN int LotType_BLOCK_LOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LotType_BLOCK_LOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *LotType_BLOCK_LOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LotType_BLOCK_LOT));
  return pyobj;
}


SWIGINTERN int QuoteCondition_FLAT_CURVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_FLAT_CURVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_FLAT_CURVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_FLAT_CURVE);
  return pyobj;
}


SWIGINTERN int QuoteCondition_REST_OF_BOOK_VWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_REST_OF_BOOK_VWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_REST_OF_BOOK_VWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_REST_OF_BOOK_VWAP);
  return pyobj;
}


SWIGINTERN int 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 *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 QuoteCondition_TRADING_RANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_TRADING_RANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_TRADING_RANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_TRADING_RANGE);
  return pyobj;
}


SWIGINTERN int QuoteCondition_HALT_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_HALT_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_HALT_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_HALT_ETH);
  return pyobj;
}


SWIGINTERN int QuoteCondition_BID_OFFER_SPECIALIST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_BID_OFFER_SPECIALIST is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_BID_OFFER_SPECIALIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_BID_OFFER_SPECIALIST);
  return pyobj;
}


SWIGINTERN int QuoteCondition_CONSOLBEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_CONSOLBEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_CONSOLBEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_CONSOLBEST);
  return pyobj;
}


SWIGINTERN int QuoteCondition_CROSSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_CROSSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_CROSSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_CROSSED);
  return pyobj;
}


SWIGINTERN int QuoteCondition_NO_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_NO_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_NO_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_NO_OPEN);
  return pyobj;
}


SWIGINTERN int QuoteCondition_HALT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_HALT is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_HALT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_HALT);
  return pyobj;
}


SWIGINTERN int QuoteCondition_PREOPENING_SAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_PREOPENING_SAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_PREOPENING_SAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_PREOPENING_SAM);
  return pyobj;
}


SWIGINTERN int QuoteCondition_OPEN_SAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_OPEN_SAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_OPEN_SAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_OPEN_SAM);
  return pyobj;
}


SWIGINTERN int QuoteCondition_RESERVED_SAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_RESERVED_SAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_RESERVED_SAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_RESERVED_SAM);
  return pyobj;
}


SWIGINTERN int QuoteCondition_OUTRIGHT_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_OUTRIGHT_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_OUTRIGHT_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_OUTRIGHT_PRICE);
  return pyobj;
}


SWIGINTERN int QuoteCondition_IMPLIED_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_IMPLIED_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_IMPLIED_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_IMPLIED_PRICE);
  return pyobj;
}


SWIGINTERN int QuoteCondition_DEPTH_ON_OFFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_DEPTH_ON_OFFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_DEPTH_ON_OFFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_DEPTH_ON_OFFER);
  return pyobj;
}


SWIGINTERN int 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 *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 QuoteCondition_REGULAR_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_REGULAR_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_REGULAR_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_REGULAR_ETH);
  return pyobj;
}


SWIGINTERN int QuoteCondition_ROTATION_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_ROTATION_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_ROTATION_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_ROTATION_ETH);
  return pyobj;
}


SWIGINTERN int QuoteCondition_NONFIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_NONFIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_NONFIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_NONFIRM);
  return pyobj;
}


SWIGINTERN int QuoteCondition_EXCHANGE_BEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_EXCHANGE_BEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_EXCHANGE_BEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_EXCHANGE_BEST);
  return pyobj;
}


SWIGINTERN int QuoteCondition_DEPTH_ON_BID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_DEPTH_ON_BID is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_DEPTH_ON_BID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_DEPTH_ON_BID);
  return pyobj;
}


SWIGINTERN int QuoteCondition_CLOSING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_CLOSING is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_CLOSING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_CLOSING);
  return pyobj;
}


SWIGINTERN int QuoteCondition_VIEW_OF_COMMON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_VIEW_OF_COMMON is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_VIEW_OF_COMMON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_VIEW_OF_COMMON);
  return pyobj;
}


SWIGINTERN int QuoteCondition_FORBIDDEN_SAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_FORBIDDEN_SAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_FORBIDDEN_SAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_FORBIDDEN_SAM);
  return pyobj;
}


SWIGINTERN int QuoteCondition_LOCKED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_LOCKED is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_LOCKED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_LOCKED);
  return pyobj;
}


SWIGINTERN int QuoteCondition_ORDER_INFLUX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_ORDER_INFLUX is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_ORDER_INFLUX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_ORDER_INFLUX);
  return pyobj;
}


SWIGINTERN int QuoteCondition_NEWS_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_NEWS_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_NEWS_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_NEWS_PENDING);
  return pyobj;
}


SWIGINTERN int QuoteCondition_RESUME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_RESUME is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_RESUME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_RESUME);
  return pyobj;
}


SWIGINTERN int QuoteCondition_TRADING_RESUME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_TRADING_RESUME is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_TRADING_RESUME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_TRADING_RESUME);
  return pyobj;
}


SWIGINTERN int QuoteCondition_OUT_OF_SEQUENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_OUT_OF_SEQUENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_OUT_OF_SEQUENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_OUT_OF_SEQUENCE);
  return pyobj;
}


SWIGINTERN int QuoteCondition_END_OF_DAY_SAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_END_OF_DAY_SAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_END_OF_DAY_SAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_END_OF_DAY_SAM);
  return pyobj;
}


SWIGINTERN int QuoteCondition_FROZEN_SAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_FROZEN_SAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_FROZEN_SAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_FROZEN_SAM);
  return pyobj;
}


SWIGINTERN int QuoteCondition_OPENING_SAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_OPENING_SAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_OPENING_SAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_OPENING_SAM);
  return pyobj;
}


SWIGINTERN int QuoteCondition_MANUAL_SLOW_QUOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_MANUAL_SLOW_QUOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_MANUAL_SLOW_QUOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_MANUAL_SLOW_QUOTE);
  return pyobj;
}


SWIGINTERN int QuoteCondition_NEWS_DISSEMINATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_NEWS_DISSEMINATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_NEWS_DISSEMINATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_NEWS_DISSEMINATION);
  return pyobj;
}


SWIGINTERN int QuoteCondition_DUE_TO_RELATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_DUE_TO_RELATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_DUE_TO_RELATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_DUE_TO_RELATED);
  return pyobj;
}


SWIGINTERN int QuoteCondition_VOLUME_ALERT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_VOLUME_ALERT is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_VOLUME_ALERT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_VOLUME_ALERT);
  return pyobj;
}


SWIGINTERN int QuoteCondition_FAST_MARKET_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_FAST_MARKET_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_FAST_MARKET_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_FAST_MARKET_ETH);
  return pyobj;
}


SWIGINTERN int QuoteCondition_INACTIVE_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_INACTIVE_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_INACTIVE_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_INACTIVE_ETH);
  return pyobj;
}


SWIGINTERN int QuoteCondition_DUE_TO_NEWS_DISSEMINATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_DUE_TO_NEWS_DISSEMINATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_DUE_TO_NEWS_DISSEMINATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_DUE_TO_NEWS_DISSEMINATION);
  return pyobj;
}


SWIGINTERN int QuoteCondition_SURVEILLANCE_SAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_SURVEILLANCE_SAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_SURVEILLANCE_SAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_SURVEILLANCE_SAM);
  return pyobj;
}


SWIGINTERN int QuoteCondition_DEPTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_DEPTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_DEPTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_DEPTH);
  return pyobj;
}


SWIGINTERN int QuoteCondition_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_OPEN);
  return pyobj;
}


SWIGINTERN int QuoteCondition_AUTOMATIC_EXECUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_AUTOMATIC_EXECUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_AUTOMATIC_EXECUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_AUTOMATIC_EXECUTION);
  return pyobj;
}


SWIGINTERN int QuoteCondition_DUE_TO_NEWS_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_DUE_TO_NEWS_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_DUE_TO_NEWS_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_DUE_TO_NEWS_PENDING);
  return pyobj;
}


SWIGINTERN int QuoteCondition_NO_ACTIVE_SAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_NO_ACTIVE_SAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_NO_ACTIVE_SAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_NO_ACTIVE_SAM);
  return pyobj;
}


SWIGINTERN int QuoteCondition_OFFER_SPECIALIST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_OFFER_SPECIALIST is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_OFFER_SPECIALIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_OFFER_SPECIALIST);
  return pyobj;
}


SWIGINTERN int QuoteCondition_SUSPENDED_SAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_SUSPENDED_SAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_SUSPENDED_SAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_SUSPENDED_SAM);
  return pyobj;
}


SWIGINTERN int QuoteCondition_RESTRICTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_RESTRICTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_RESTRICTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_RESTRICTED);
  return pyobj;
}


SWIGINTERN int QuoteCondition_NON_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_NON_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_NON_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_NON_FIRM);
  return pyobj;
}


SWIGINTERN int QuoteCondition_CLOSED_INACTIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_CLOSED_INACTIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_CLOSED_INACTIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_CLOSED_INACTIVE);
  return pyobj;
}


SWIGINTERN int QuoteCondition_ADDITIONAL_INFO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_ADDITIONAL_INFO is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_ADDITIONAL_INFO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_ADDITIONAL_INFO);
  return pyobj;
}


SWIGINTERN int QuoteCondition_EQUIPMENT_CHANGEOVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_EQUIPMENT_CHANGEOVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_EQUIPMENT_CHANGEOVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_EQUIPMENT_CHANGEOVER);
  return pyobj;
}


SWIGINTERN int QuoteCondition_EXCHBEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_EXCHBEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_EXCHBEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_EXCHBEST);
  return pyobj;
}


SWIGINTERN int QuoteCondition_FAST_TRADING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_FAST_TRADING is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_FAST_TRADING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_FAST_TRADING);
  return pyobj;
}


SWIGINTERN int QuoteCondition_FULL_CURVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_FULL_CURVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_FULL_CURVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_FULL_CURVE);
  return pyobj;
}


SWIGINTERN int QuoteCondition_MEDIAN_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_MEDIAN_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_MEDIAN_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_MEDIAN_PRICE);
  return pyobj;
}


SWIGINTERN int QuoteCondition_OPEN_ACTIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_OPEN_ACTIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_OPEN_ACTIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_OPEN_ACTIVE);
  return pyobj;
}


SWIGINTERN int QuoteCondition_ORDER_IMBALANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_ORDER_IMBALANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_ORDER_IMBALANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_ORDER_IMBALANCE);
  return pyobj;
}


SWIGINTERN int QuoteCondition_AUTOMATIC_EXECUTION_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_AUTOMATIC_EXECUTION_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_AUTOMATIC_EXECUTION_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_AUTOMATIC_EXECUTION_ETH);
  return pyobj;
}


SWIGINTERN int QuoteCondition_ROTATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_ROTATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_ROTATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_ROTATION);
  return pyobj;
}


SWIGINTERN int QuoteCondition_BID_SPECIALIST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_BID_SPECIALIST is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_BID_SPECIALIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_BID_SPECIALIST);
  return pyobj;
}


SWIGINTERN int QuoteCondition_FAST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_FAST is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_FAST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_FAST);
  return pyobj;
}


SWIGINTERN int QuoteCondition_CONSOLIDATED_BEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_CONSOLIDATED_BEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_CONSOLIDATED_BEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_CONSOLIDATED_BEST);
  return pyobj;
}


SWIGINTERN int QuoteCondition_CLOSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_CLOSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteCondition_CLOSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_CLOSED);
  return pyobj;
}


SWIGINTERN int PartyRelationship_OWNED_BY_30_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_OWNED_BY_30 is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_OWNED_BY_30_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_OWNED_BY_30));
  return pyobj;
}


SWIGINTERN int PartyRelationship_PROVIDES_QUOTES_TO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_PROVIDES_QUOTES_TO is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_PROVIDES_QUOTES_TO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_PROVIDES_QUOTES_TO));
  return pyobj;
}


SWIGINTERN int PartyRelationship_POSTS_TRADES_TO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_POSTS_TRADES_TO is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_POSTS_TRADES_TO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_POSTS_TRADES_TO));
  return pyobj;
}


SWIGINTERN int PartyRelationship_REGULATORY_OWNER_OF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_REGULATORY_OWNER_OF is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_REGULATORY_OWNER_OF_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_REGULATORY_OWNER_OF));
  return pyobj;
}


SWIGINTERN int PartyRelationship_SUBSIDIARY_OF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_SUBSIDIARY_OF is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_SUBSIDIARY_OF_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_SUBSIDIARY_OF));
  return pyobj;
}


SWIGINTERN int PartyRelationship_HAS_MEMBERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_HAS_MEMBERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_HAS_MEMBERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_HAS_MEMBERS));
  return pyobj;
}


SWIGINTERN int PartyRelationship_ENTERS_TRADES_THROUGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_ENTERS_TRADES_THROUGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_ENTERS_TRADES_THROUGH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_ENTERS_TRADES_THROUGH));
  return pyobj;
}


SWIGINTERN int PartyRelationship_BENEFICIAL_OWNER_OF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_BENEFICIAL_OWNER_OF is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_BENEFICIAL_OWNER_OF_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_BENEFICIAL_OWNER_OF));
  return pyobj;
}


SWIGINTERN int PartyRelationship_OWNED_BY_34_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_OWNED_BY_34 is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_OWNED_BY_34_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_OWNED_BY_34));
  return pyobj;
}


SWIGINTERN int PartyRelationship_CONTROLS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_CONTROLS is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_CONTROLS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_CONTROLS));
  return pyobj;
}


SWIGINTERN int PartyRelationship_REQUESTS_QUOTES_FROM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_REQUESTS_QUOTES_FROM is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_REQUESTS_QUOTES_FROM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_REQUESTS_QUOTES_FROM));
  return pyobj;
}


SWIGINTERN int PartyRelationship_SPONSORS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_SPONSORS is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_SPONSORS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_SPONSORS));
  return pyobj;
}


SWIGINTERN int PartyRelationship_CLEARS_THROUGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_CLEARS_THROUGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_CLEARS_THROUGH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_CLEARS_THROUGH));
  return pyobj;
}


SWIGINTERN int PartyRelationship_OWNED_BY_36_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_OWNED_BY_36 is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_OWNED_BY_36_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_OWNED_BY_36));
  return pyobj;
}


SWIGINTERN int PartyRelationship_BROKERS_TRADES_THROUGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_BROKERS_TRADES_THROUGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_BROKERS_TRADES_THROUGH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_BROKERS_TRADES_THROUGH));
  return pyobj;
}


SWIGINTERN int PartyRelationship_INVESTS_THROUGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_INVESTS_THROUGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_INVESTS_THROUGH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_INVESTS_THROUGH));
  return pyobj;
}


SWIGINTERN int PartyRelationship_PARTICIPANT_OF_MARKETPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_PARTICIPANT_OF_MARKETPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_PARTICIPANT_OF_MARKETPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_PARTICIPANT_OF_MARKETPLACE));
  return pyobj;
}


SWIGINTERN int PartyRelationship_LEGAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_LEGAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_LEGAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_LEGAL));
  return pyobj;
}


SWIGINTERN int PartyRelationship_ENTERS_TRADES_FOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_ENTERS_TRADES_FOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_ENTERS_TRADES_FOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_ENTERS_TRADES_FOR));
  return pyobj;
}


SWIGINTERN int PartyRelationship_CARRIES_POSITIONS_FOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_CARRIES_POSITIONS_FOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_CARRIES_POSITIONS_FOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_CARRIES_POSITIONS_FOR));
  return pyobj;
}


SWIGINTERN int PartyRelationship_IS_GUARANTEED_BY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_IS_GUARANTEED_BY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_IS_GUARANTEED_BY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_IS_GUARANTEED_BY));
  return pyobj;
}


SWIGINTERN int PartyRelationship_IS_CONTROLLED_BY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_IS_CONTROLLED_BY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_IS_CONTROLLED_BY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_IS_CONTROLLED_BY));
  return pyobj;
}


SWIGINTERN int PartyRelationship_PROVIDES_TRADING_SERVICES_FOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_PROVIDES_TRADING_SERVICES_FOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_PROVIDES_TRADING_SERVICES_FOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_PROVIDES_TRADING_SERVICES_FOR));
  return pyobj;
}


SWIGINTERN int PartyRelationship_IS_ALSO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_IS_ALSO is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_IS_ALSO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_IS_ALSO));
  return pyobj;
}


SWIGINTERN int PartyRelationship_PARENT_FIRM_FOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_PARENT_FIRM_FOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_PARENT_FIRM_FOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_PARENT_FIRM_FOR));
  return pyobj;
}


SWIGINTERN int PartyRelationship_APPROVED_BY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_APPROVED_BY is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_APPROVED_BY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_APPROVED_BY));
  return pyobj;
}


SWIGINTERN int PartyRelationship_APPROVES_OF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_APPROVES_OF is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_APPROVES_OF_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_APPROVES_OF));
  return pyobj;
}


SWIGINTERN int PartyRelationship_USES_TRADING_SERVICES_OF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_USES_TRADING_SERVICES_OF is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_USES_TRADING_SERVICES_OF_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_USES_TRADING_SERVICES_OF));
  return pyobj;
}


SWIGINTERN int PartyRelationship_PROVIDES_GUARANTEE_FOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_PROVIDES_GUARANTEE_FOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_PROVIDES_GUARANTEE_FOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_PROVIDES_GUARANTEE_FOR));
  return pyobj;
}


SWIGINTERN int PartyRelationship_SPONSORED_THROUGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_SPONSORED_THROUGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_SPONSORED_THROUGH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_SPONSORED_THROUGH));
  return pyobj;
}


SWIGINTERN int PartyRelationship_TRADES_FOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_TRADES_FOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_TRADES_FOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_TRADES_FOR));
  return pyobj;
}


SWIGINTERN int PartyRelationship_CLEARS_FOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_CLEARS_FOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_CLEARS_FOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_CLEARS_FOR));
  return pyobj;
}


SWIGINTERN int PartyRelationship_BROKERS_TRADES_FOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_BROKERS_TRADES_FOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_BROKERS_TRADES_FOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_BROKERS_TRADES_FOR));
  return pyobj;
}


SWIGINTERN int PartyRelationship_INVESTS_FOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_INVESTS_FOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_INVESTS_FOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_INVESTS_FOR));
  return pyobj;
}


SWIGINTERN int PartyRelationship_PROVIDES_MARKETPLACE_FOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_PROVIDES_MARKETPLACE_FOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_PROVIDES_MARKETPLACE_FOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_PROVIDES_MARKETPLACE_FOR));
  return pyobj;
}


SWIGINTERN int PartyRelationship_MEMBER_OF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_MEMBER_OF is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_MEMBER_OF_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_MEMBER_OF));
  return pyobj;
}


SWIGINTERN int PartyRelationship_TRADES_THROUGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRelationship_TRADES_THROUGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *PartyRelationship_TRADES_THROUGH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_TRADES_THROUGH));
  return pyobj;
}


SWIGINTERN int SettlLocation_EUROCLEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlLocation_EUROCLEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlLocation_EUROCLEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlLocation_EUROCLEAR);
  return pyobj;
}


SWIGINTERN int SettlLocation_CEDEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlLocation_CEDEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlLocation_CEDEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlLocation_CEDEL);
  return pyobj;
}


SWIGINTERN int SettlLocation_PARTICIPANT_TRUST_COMPANY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlLocation_PARTICIPANT_TRUST_COMPANY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlLocation_PARTICIPANT_TRUST_COMPANY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlLocation_PARTICIPANT_TRUST_COMPANY);
  return pyobj;
}


SWIGINTERN int SettlLocation_PHYSICAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlLocation_PHYSICAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlLocation_PHYSICAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlLocation_PHYSICAL);
  return pyobj;
}


SWIGINTERN int SettlLocation_EURO_CLEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlLocation_EURO_CLEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlLocation_EURO_CLEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlLocation_EURO_CLEAR);
  return pyobj;
}


SWIGINTERN int SettlLocation_FEDERALBOOKENTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlLocation_FEDERALBOOKENTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlLocation_FEDERALBOOKENTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlLocation_FEDERALBOOKENTRY);
  return pyobj;
}


SWIGINTERN int SettlLocation_PARTICIPANTTRUSTCOMPANY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlLocation_PARTICIPANTTRUSTCOMPANY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlLocation_PARTICIPANTTRUSTCOMPANY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlLocation_PARTICIPANTTRUSTCOMPANY);
  return pyobj;
}


SWIGINTERN int SettlLocation_DEPOSITORY_TRUST_COMPANY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlLocation_DEPOSITORY_TRUST_COMPANY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlLocation_DEPOSITORY_TRUST_COMPANY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlLocation_DEPOSITORY_TRUST_COMPANY);
  return pyobj;
}


SWIGINTERN int SettlLocation_DEPOSITORYTRUSTCOMPANY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlLocation_DEPOSITORYTRUSTCOMPANY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlLocation_DEPOSITORYTRUSTCOMPANY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlLocation_DEPOSITORYTRUSTCOMPANY);
  return pyobj;
}


SWIGINTERN int SettlLocation_LOCAL_MARKET_SETTLE_LOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlLocation_LOCAL_MARKET_SETTLE_LOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlLocation_LOCAL_MARKET_SETTLE_LOCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlLocation_LOCAL_MARKET_SETTLE_LOCATION);
  return pyobj;
}


SWIGINTERN int SettlLocation_LOCALMARKETSETTLELOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlLocation_LOCALMARKETSETTLELOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlLocation_LOCALMARKETSETTLELOCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlLocation_LOCALMARKETSETTLELOCATION);
  return pyobj;
}


SWIGINTERN int SettlLocation_FEDERAL_BOOK_ENTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlLocation_FEDERAL_BOOK_ENTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SettlLocation_FEDERAL_BOOK_ENTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlLocation_FEDERAL_BOOK_ENTRY);
  return pyobj;
}


SWIGINTERN int DiscretionScope_LOCAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionScope_LOCAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *DiscretionScope_LOCAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionScope_LOCAL));
  return pyobj;
}


SWIGINTERN int DiscretionScope_NATIONAL_EXCLUDING_LOCAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionScope_NATIONAL_EXCLUDING_LOCAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 DiscretionScope_NATIONALEXCLUDINGLOCAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionScope_NATIONALEXCLUDINGLOCAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *DiscretionScope_NATIONALEXCLUDINGLOCAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionScope_NATIONALEXCLUDINGLOCAL));
  return pyobj;
}


SWIGINTERN int DiscretionScope_GLOBAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionScope_GLOBAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *DiscretionScope_GLOBAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionScope_GLOBAL));
  return pyobj;
}


SWIGINTERN int DiscretionScope_NATIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionScope_NATIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *DiscretionScope_NATIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionScope_NATIONAL));
  return pyobj;
}


SWIGINTERN int DiscretionScope_LOCALEXCHANGEECNATS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionScope_LOCALEXCHANGEECNATS is read-only.");
  return 1;
}


SWIGINTERN PyObject *DiscretionScope_LOCALEXCHANGEECNATS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionScope_LOCALEXCHANGEECNATS));
  return pyobj;
}


SWIGINTERN int OwnerType_NETWORKINGSUBACCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_NETWORKINGSUBACCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *OwnerType_NETWORKINGSUBACCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_NETWORKINGSUBACCT));
  return pyobj;
}


SWIGINTERN int OwnerType_PUBLIC_COMPANY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_PUBLIC_COMPANY is read-only.");
  return 1;
}


SWIGINTERN PyObject *OwnerType_PUBLIC_COMPANY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_PUBLIC_COMPANY));
  return pyobj;
}


SWIGINTERN int OwnerType_INDIVIDUAL_TRUSTEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_INDIVIDUAL_TRUSTEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *OwnerType_INDIVIDUAL_TRUSTEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_INDIVIDUAL_TRUSTEE));
  return pyobj;
}


SWIGINTERN int 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 *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 OwnerType_INDIVIDUAL_INVESTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_INDIVIDUAL_INVESTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *OwnerType_INDIVIDUAL_INVESTOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_INDIVIDUAL_INVESTOR));
  return pyobj;
}


SWIGINTERN int OwnerType_COMPANY_TRUSTEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_COMPANY_TRUSTEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *OwnerType_COMPANY_TRUSTEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_COMPANY_TRUSTEE));
  return pyobj;
}


SWIGINTERN int OwnerType_CORPBODY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_CORPBODY is read-only.");
  return 1;
}


SWIGINTERN PyObject *OwnerType_CORPBODY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_CORPBODY));
  return pyobj;
}


SWIGINTERN int OwnerType_INDIVTRUSTEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_INDIVTRUSTEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *OwnerType_INDIVTRUSTEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_INDIVTRUSTEE));
  return pyobj;
}


SWIGINTERN int OwnerType_PENSIONPLAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_PENSIONPLAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *OwnerType_PENSIONPLAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_PENSIONPLAN));
  return pyobj;
}


SWIGINTERN int OwnerType_PRIVATE_COMPANY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_PRIVATE_COMPANY is read-only.");
  return 1;
}


SWIGINTERN PyObject *OwnerType_PRIVATE_COMPANY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_PRIVATE_COMPANY));
  return pyobj;
}


SWIGINTERN int OwnerType_NETWORKING_SUB_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_NETWORKING_SUB_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 OwnerType_NON_PROFITORG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_NON_PROFITORG is read-only.");
  return 1;
}


SWIGINTERN PyObject *OwnerType_NON_PROFITORG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_NON_PROFITORG));
  return pyobj;
}


SWIGINTERN int OwnerType_PRIVATECOMPANY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_PRIVATECOMPANY is read-only.");
  return 1;
}


SWIGINTERN PyObject *OwnerType_PRIVATECOMPANY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_PRIVATECOMPANY));
  return pyobj;
}


SWIGINTERN int OwnerType_PENSION_PLAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_PENSION_PLAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *OwnerType_PENSION_PLAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_PENSION_PLAN));
  return pyobj;
}


SWIGINTERN int OwnerType_COMPANYTRUSTEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_COMPANYTRUSTEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *OwnerType_COMPANYTRUSTEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_COMPANYTRUSTEE));
  return pyobj;
}


SWIGINTERN int OwnerType_TRUSTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_TRUSTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *OwnerType_TRUSTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_TRUSTS));
  return pyobj;
}


SWIGINTERN int OwnerType_FIDUCIARIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_FIDUCIARIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *OwnerType_FIDUCIARIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_FIDUCIARIES));
  return pyobj;
}


SWIGINTERN int OwnerType_INDIVINVESTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_INDIVINVESTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *OwnerType_INDIVINVESTOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_INDIVINVESTOR));
  return pyobj;
}


SWIGINTERN int OwnerType_NON_PROFIT_ORGANIZATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_NON_PROFIT_ORGANIZATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 OwnerType_CORPORATE_BODY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_CORPORATE_BODY is read-only.");
  return 1;
}


SWIGINTERN PyObject *OwnerType_CORPORATE_BODY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_CORPORATE_BODY));
  return pyobj;
}


SWIGINTERN int OwnerType_PUBLICCOMPANY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_PUBLICCOMPANY is read-only.");
  return 1;
}


SWIGINTERN PyObject *OwnerType_PUBLICCOMPANY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_PUBLICCOMPANY));
  return pyobj;
}


SWIGINTERN int OwnerType_CUSTODIANMINORSACT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_CUSTODIANMINORSACT is read-only.");
  return 1;
}


SWIGINTERN PyObject *OwnerType_CUSTODIANMINORSACT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_CUSTODIANMINORSACT));
  return pyobj;
}


SWIGINTERN int OwnerType_NOMINEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_NOMINEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *OwnerType_NOMINEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_NOMINEE));
  return pyobj;
}


SWIGINTERN int ApplQueueResolution_END_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplQueueResolution_END_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *ApplQueueResolution_END_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplQueueResolution_END_SESSION));
  return pyobj;
}


SWIGINTERN int ApplQueueResolution_QUEUEFLUSHED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplQueueResolution_QUEUEFLUSHED is read-only.");
  return 1;
}


SWIGINTERN PyObject *ApplQueueResolution_QUEUEFLUSHED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplQueueResolution_QUEUEFLUSHED));
  return pyobj;
}


SWIGINTERN int ApplQueueResolution_QUEUE_FLUSHED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplQueueResolution_QUEUE_FLUSHED is read-only.");
  return 1;
}


SWIGINTERN PyObject *ApplQueueResolution_QUEUE_FLUSHED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplQueueResolution_QUEUE_FLUSHED));
  return pyobj;
}


SWIGINTERN int ApplQueueResolution_ENDSESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplQueueResolution_ENDSESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *ApplQueueResolution_ENDSESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplQueueResolution_ENDSESSION));
  return pyobj;
}


SWIGINTERN int ApplQueueResolution_OVERLAYLAST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplQueueResolution_OVERLAYLAST is read-only.");
  return 1;
}


SWIGINTERN PyObject *ApplQueueResolution_OVERLAYLAST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplQueueResolution_OVERLAYLAST));
  return pyobj;
}


SWIGINTERN int ApplQueueResolution_OVERLAY_LAST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplQueueResolution_OVERLAY_LAST is read-only.");
  return 1;
}


SWIGINTERN PyObject *ApplQueueResolution_OVERLAY_LAST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplQueueResolution_OVERLAY_LAST));
  return pyobj;
}


SWIGINTERN int ApplQueueResolution_NOACTIONTAKEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplQueueResolution_NOACTIONTAKEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *ApplQueueResolution_NOACTIONTAKEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplQueueResolution_NOACTIONTAKEN));
  return pyobj;
}


SWIGINTERN int ApplQueueResolution_NO_ACTION_TAKEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplQueueResolution_NO_ACTION_TAKEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 QuoteResponseLevel_SUMMARY_ACKNOWLEDGEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteResponseLevel_SUMMARY_ACKNOWLEDGEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteResponseLevel_SUMMARY_ACKNOWLEDGEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteResponseLevel_SUMMARY_ACKNOWLEDGEMENT));
  return pyobj;
}


SWIGINTERN int QuoteResponseLevel_ACKEACH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteResponseLevel_ACKEACH is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteResponseLevel_ACKEACH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteResponseLevel_ACKEACH));
  return pyobj;
}


SWIGINTERN int 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 *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 QuoteResponseLevel_ACKNEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteResponseLevel_ACKNEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteResponseLevel_ACKNEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteResponseLevel_ACKNEG));
  return pyobj;
}


SWIGINTERN int QuoteResponseLevel_NOACK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteResponseLevel_NOACK is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteResponseLevel_NOACK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteResponseLevel_NOACK));
  return pyobj;
}


SWIGINTERN int QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGES is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 QuoteResponseLevel_NO_ACKNOWLEDGEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteResponseLevel_NO_ACKNOWLEDGEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteResponseLevel_NO_ACKNOWLEDGEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteResponseLevel_NO_ACKNOWLEDGEMENT));
  return pyobj;
}


SWIGINTERN int ExecAckStatus_RECEIVED_NOT_YET_PROCESSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecAckStatus_RECEIVED_NOT_YET_PROCESSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ExecAckStatus_DONT_KNOW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecAckStatus_DONT_KNOW is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecAckStatus_DONT_KNOW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecAckStatus_DONT_KNOW));
  return pyobj;
}


SWIGINTERN int ExecAckStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecAckStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *ExecAckStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecAckStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int NetGrossInd_NET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NetGrossInd_NET is read-only.");
  return 1;
}


SWIGINTERN PyObject *NetGrossInd_NET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NetGrossInd_NET));
  return pyobj;
}


SWIGINTERN int NetGrossInd_GROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NetGrossInd_GROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *NetGrossInd_GROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NetGrossInd_GROSS));
  return pyobj;
}


SWIGINTERN int CxlType_PARTIAL_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlType_PARTIAL_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *CxlType_PARTIAL_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CxlType_PARTIAL_CANCEL));
  return pyobj;
}


SWIGINTERN int CxlType_FULL_REMAINING_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlType_FULL_REMAINING_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 DeskTypeSource_NASD_OATS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskTypeSource_NASD_OATS is read-only.");
  return 1;
}


SWIGINTERN PyObject *DeskTypeSource_NASD_OATS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeskTypeSource_NASD_OATS));
  return pyobj;
}


SWIGINTERN int DiscretionRoundDirection_MOREPASSIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionRoundDirection_MOREPASSIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *DiscretionRoundDirection_MOREPASSIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionRoundDirection_MOREPASSIVE));
  return pyobj;
}


SWIGINTERN int DiscretionRoundDirection_MOREAGGRESSIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionRoundDirection_MOREAGGRESSIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *DiscretionRoundDirection_MOREAGGRESSIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionRoundDirection_MOREAGGRESSIVE));
  return pyobj;
}


SWIGINTERN int DiscretionRoundDirection_MORE_AGGRESSIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionRoundDirection_MORE_AGGRESSIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *DiscretionRoundDirection_MORE_AGGRESSIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionRoundDirection_MORE_AGGRESSIVE));
  return pyobj;
}


SWIGINTERN int DiscretionRoundDirection_MORE_PASSIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionRoundDirection_MORE_PASSIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *DiscretionRoundDirection_MORE_PASSIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionRoundDirection_MORE_PASSIVE));
  return pyobj;
}


SWIGINTERN int BidDescriptorType_COUNTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidDescriptorType_COUNTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *BidDescriptorType_COUNTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BidDescriptorType_COUNTRY));
  return pyobj;
}


SWIGINTERN int BidDescriptorType_INDEX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidDescriptorType_INDEX is read-only.");
  return 1;
}


SWIGINTERN PyObject *BidDescriptorType_INDEX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BidDescriptorType_INDEX));
  return pyobj;
}


SWIGINTERN int BidDescriptorType_SECTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidDescriptorType_SECTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *BidDescriptorType_SECTOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BidDescriptorType_SECTOR));
  return pyobj;
}


SWIGINTERN int NetworkStatusResponseType_INCREMENTAL_UPDATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NetworkStatusResponseType_INCREMENTAL_UPDATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *NetworkStatusResponseType_INCREMENTAL_UPDATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NetworkStatusResponseType_INCREMENTAL_UPDATE));
  return pyobj;
}


SWIGINTERN int NetworkStatusResponseType_INCREMENTALUPDATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NetworkStatusResponseType_INCREMENTALUPDATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *NetworkStatusResponseType_INCREMENTALUPDATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NetworkStatusResponseType_INCREMENTALUPDATE));
  return pyobj;
}


SWIGINTERN int NetworkStatusResponseType_FULL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NetworkStatusResponseType_FULL is read-only.");
  return 1;
}


SWIGINTERN PyObject *NetworkStatusResponseType_FULL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NetworkStatusResponseType_FULL));
  return pyobj;
}


SWIGINTERN int QuoteType_INDICATIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteType_INDICATIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteType_INDICATIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteType_INDICATIVE));
  return pyobj;
}


SWIGINTERN int QuoteType_RESTRICTEDTRADEABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteType_RESTRICTEDTRADEABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteType_RESTRICTEDTRADEABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteType_RESTRICTEDTRADEABLE));
  return pyobj;
}


SWIGINTERN int QuoteType_RESTRICTED_TRADEABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteType_RESTRICTED_TRADEABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteType_RESTRICTED_TRADEABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteType_RESTRICTED_TRADEABLE));
  return pyobj;
}


SWIGINTERN int QuoteType_TRADEABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteType_TRADEABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteType_TRADEABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteType_TRADEABLE));
  return pyobj;
}


SWIGINTERN int QuoteType_COUNTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteType_COUNTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *QuoteType_COUNTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteType_COUNTER));
  return pyobj;
}


SWIGINTERN int DiscretionInst_RELVWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionInst_RELVWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *DiscretionInst_RELVWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELVWAP));
  return pyobj;
}


SWIGINTERN int DiscretionInst_RELLOCPRIMPX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionInst_RELLOCPRIMPX is read-only.");
  return 1;
}


SWIGINTERN PyObject *DiscretionInst_RELLOCPRIMPX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELLOCPRIMPX));
  return pyobj;
}


SWIGINTERN int DiscretionInst_RELATED_TO_MARKET_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionInst_RELATED_TO_MARKET_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 DiscretionInst_RELMIDPX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionInst_RELMIDPX is read-only.");
  return 1;
}


SWIGINTERN PyObject *DiscretionInst_RELMIDPX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELMIDPX));
  return pyobj;
}


SWIGINTERN int DiscretionInst_RELATED_TO_VWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionInst_RELATED_TO_VWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 DiscretionInst_RELATED_TO_MIDPOINT_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionInst_RELATED_TO_MIDPOINT_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 DiscretionInst_RELDISPPX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionInst_RELDISPPX is read-only.");
  return 1;
}


SWIGINTERN PyObject *DiscretionInst_RELDISPPX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELDISPPX));
  return pyobj;
}


SWIGINTERN int DiscretionInst_RELATED_TO_DISPLAYED_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionInst_RELATED_TO_DISPLAYED_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 DiscretionInst_RELATED_TO_PRIMARY_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionInst_RELATED_TO_PRIMARY_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 DiscretionInst_AVERAGE_PRICE_GUARANTEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionInst_AVERAGE_PRICE_GUARANTEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 DiscretionInst_RELMKTPX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionInst_RELMKTPX is read-only.");
  return 1;
}


SWIGINTERN PyObject *DiscretionInst_RELMKTPX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELMKTPX));
  return pyobj;
}


SWIGINTERN int DiscretionInst_RELPRIMPX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionInst_RELPRIMPX is read-only.");
  return 1;
}


SWIGINTERN PyObject *DiscretionInst_RELPRIMPX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELPRIMPX));
  return pyobj;
}


SWIGINTERN int DiscretionInst_RELLSTPX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionInst_RELLSTPX is read-only.");
  return 1;
}


SWIGINTERN PyObject *DiscretionInst_RELLSTPX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELLSTPX));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 CrossPrioritization_BUY_SIDE_IS_PRIORITIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossPrioritization_BUY_SIDE_IS_PRIORITIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 CrossPrioritization_SELL_SIDE_IS_PRIORITIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossPrioritization_SELL_SIDE_IS_PRIORITIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 CrossPrioritization_BUY_SIDE_PRIORITIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossPrioritization_BUY_SIDE_PRIORITIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *CrossPrioritization_BUY_SIDE_PRIORITIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossPrioritization_BUY_SIDE_PRIORITIZED));
  return pyobj;
}


SWIGINTERN int CrossPrioritization_SELL_SIDE_PRIORITIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossPrioritization_SELL_SIDE_PRIORITIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *CrossPrioritization_SELL_SIDE_PRIORITIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossPrioritization_SELL_SIDE_PRIORITIZED));
  return pyobj;
}


SWIGINTERN int CrossPrioritization_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossPrioritization_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *CrossPrioritization_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossPrioritization_NONE));
  return pyobj;
}


SWIGINTERN int CrossPrioritization_SELLSIDE_PRIORITIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossPrioritization_SELLSIDE_PRIORITIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *CrossPrioritization_SELLSIDE_PRIORITIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossPrioritization_SELLSIDE_PRIORITIZED));
  return pyobj;
}


SWIGINTERN int CrossPrioritization_BUYSIDE_PRIORITIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossPrioritization_BUYSIDE_PRIORITIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *CrossPrioritization_BUYSIDE_PRIORITIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossPrioritization_BUYSIDE_PRIORITIZED));
  return pyobj;
}


SWIGINTERN int IOIOthSvc_AUTEX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIOthSvc_AUTEX is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIOthSvc_AUTEX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIOthSvc_AUTEX));
  return pyobj;
}


SWIGINTERN int IOIOthSvc_BRIDGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIOthSvc_BRIDGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *IOIOthSvc_BRIDGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIOthSvc_BRIDGE));
  return pyobj;
}


SWIGINTERN int MDReqRejReason_UNSUPPSUB_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPSUB is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDReqRejReason_UNSUPPSUB_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPSUB));
  return pyobj;
}


SWIGINTERN int MDReqRejReason_UNSUPPORTED_MDENTRYTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPORTED_MDENTRYTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDReqRejReason_UNSUPPORTED_MDENTRYTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_MDENTRYTYPE));
  return pyobj;
}


SWIGINTERN int MDReqRejReason_INSUFFICIENT_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_INSUFFICIENT_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDReqRejReason_INSUFFICIENT_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_INSUFFICIENT_CREDIT));
  return pyobj;
}


SWIGINTERN int MDReqRejReason_UNSUPPMKTDEPTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPMKTDEPTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDReqRejReason_UNSUPPMKTDEPTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPMKTDEPTH));
  return pyobj;
}


SWIGINTERN int MDReqRejReason_UNSUPPENTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPENTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDReqRejReason_UNSUPPENTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPENTRY));
  return pyobj;
}


SWIGINTERN int MDReqRejReason_INSUFFICIENT_BANDWIDTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_INSUFFICIENT_BANDWIDTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDReqRejReason_INSUFFICIENT_BANDWIDTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_INSUFFICIENT_BANDWIDTH));
  return pyobj;
}


SWIGINTERN int MDReqRejReason_UNSUPPORTED_SCOPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPORTED_SCOPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDReqRejReason_UNSUPPORTED_SCOPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_SCOPE));
  return pyobj;
}


SWIGINTERN int MDReqRejReason_UNSUPPMDIMPLICITDELETE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPMDIMPLICITDELETE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDReqRejReason_UNSUPPMDIMPLICITDELETE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPMDIMPLICITDELETE));
  return pyobj;
}


SWIGINTERN int MDReqRejReason_UNSUPPORTED_TRADINGSESSIONID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPORTED_TRADINGSESSIONID is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDReqRejReason_UNSUPPORTED_TRADINGSESSIONID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_TRADINGSESSIONID));
  return pyobj;
}


SWIGINTERN int MDReqRejReason_UNKNOWNSYM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNKNOWNSYM is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDReqRejReason_UNKNOWNSYM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNKNOWNSYM));
  return pyobj;
}


SWIGINTERN int MDReqRejReason_UNSUPPMDUPDATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPMDUPDATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDReqRejReason_UNSUPPMDUPDATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPMDUPDATE));
  return pyobj;
}


SWIGINTERN int MDReqRejReason_UNSUPPPOSITIONEFFECTSETTLEFLAG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPPOSITIONEFFECTSETTLEFLAG is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDReqRejReason_UNSUPPPOSITIONEFFECTSETTLEFLAG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPPOSITIONEFFECTSETTLEFLAG));
  return pyobj;
}


SWIGINTERN int MDReqRejReason_DUPLICATE_MDREQID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_DUPLICATE_MDREQID is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDReqRejReason_DUPLICATE_MDREQID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_DUPLICATE_MDREQID));
  return pyobj;
}


SWIGINTERN int MDReqRejReason_DUPID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_DUPID is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDReqRejReason_DUPID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_DUPID));
  return pyobj;
}


SWIGINTERN int MDReqRejReason_UNSUPPORTED_AGGREGATEDBOOK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPORTED_AGGREGATEDBOOK is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDReqRejReason_UNSUPPORTED_AGGREGATEDBOOK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_AGGREGATEDBOOK));
  return pyobj;
}


SWIGINTERN int MDReqRejReason_UNSUPPORTED_MDUPDATETYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPORTED_MDUPDATETYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDReqRejReason_UNSUPPORTED_MDUPDATETYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_MDUPDATETYPE));
  return pyobj;
}


SWIGINTERN int MDReqRejReason_UNSUPPORTED_SUBSCRIPTIONREQUESTTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPORTED_SUBSCRIPTIONREQUESTTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDReqRejReason_UNSUPPORTED_SUBSCRIPTIONREQUESTTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_SUBSCRIPTIONREQUESTTYPE));
  return pyobj;
}


SWIGINTERN int MDReqRejReason_UNKNOWN_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNKNOWN_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDReqRejReason_UNKNOWN_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNKNOWN_SYMBOL));
  return pyobj;
}


SWIGINTERN int MDReqRejReason_INSBAND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_INSBAND is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDReqRejReason_INSBAND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_INSBAND));
  return pyobj;
}


SWIGINTERN int MDReqRejReason_UNSUPPSCOPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPSCOPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDReqRejReason_UNSUPPSCOPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPSCOPE));
  return pyobj;
}


SWIGINTERN int MDReqRejReason_UNSUPPORTED_OPENCLOSESETTLEFLAG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPORTED_OPENCLOSESETTLEFLAG is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDReqRejReason_UNSUPPORTED_OPENCLOSESETTLEFLAG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_OPENCLOSESETTLEFLAG));
  return pyobj;
}


SWIGINTERN int MDReqRejReason_UNSUPPORTED_MARKETDEPTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPORTED_MARKETDEPTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDReqRejReason_UNSUPPORTED_MARKETDEPTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_MARKETDEPTH));
  return pyobj;
}


SWIGINTERN int MDReqRejReason_UNSUPPAGGBK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPAGGBK is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDReqRejReason_UNSUPPAGGBK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPAGGBK));
  return pyobj;
}


SWIGINTERN int MDReqRejReason_INSUFFICIENT_PERMISSIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_INSUFFICIENT_PERMISSIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDReqRejReason_INSUFFICIENT_PERMISSIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_INSUFFICIENT_PERMISSIONS));
  return pyobj;
}


SWIGINTERN int MDReqRejReason_INSPERM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_INSPERM is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDReqRejReason_INSPERM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_INSPERM));
  return pyobj;
}


SWIGINTERN int MDReqRejReason_UNSUPPTRDSESSIONID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPTRDSESSIONID is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDReqRejReason_UNSUPPTRDSESSIONID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPTRDSESSIONID));
  return pyobj;
}


SWIGINTERN int MDReqRejReason_UNSUPPORTED_MDIMPLICITDELETE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPORTED_MDIMPLICITDELETE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MDReqRejReason_UNSUPPORTED_MDIMPLICITDELETE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_MDIMPLICITDELETE));
  return pyobj;
}


SWIGINTERN int 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 *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 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 *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 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 *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 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 *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 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 *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 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 *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 ApplReqType_CANCEL_RETRANSMISSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplReqType_CANCEL_RETRANSMISSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *ApplReqType_CANCEL_RETRANSMISSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplReqType_CANCEL_RETRANSMISSION));
  return pyobj;
}


SWIGINTERN int AggressorIndicator_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AggressorIndicator_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *AggressorIndicator_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AggressorIndicator_NO));
  return pyobj;
}


SWIGINTERN int AggressorIndicator_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AggressorIndicator_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *AggressorIndicator_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AggressorIndicator_YES));
  return pyobj;
}


SWIGINTERN int BusinessRejectReason_APPNA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_APPNA is read-only.");
  return 1;
}


SWIGINTERN PyObject *BusinessRejectReason_APPNA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_APPNA));
  return pyobj;
}


SWIGINTERN int BusinessRejectReason_UNKNOWN_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_UNKNOWN_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *BusinessRejectReason_UNKNOWN_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_UNKNOWN_SECURITY));
  return pyobj;
}


SWIGINTERN int BusinessRejectReason_UNKNMSGTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_UNKNMSGTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *BusinessRejectReason_UNKNMSGTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_UNKNMSGTYPE));
  return pyobj;
}


SWIGINTERN int BusinessRejectReason_CONDFLDMISS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_CONDFLDMISS is read-only.");
  return 1;
}


SWIGINTERN PyObject *BusinessRejectReason_CONDFLDMISS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_CONDFLDMISS));
  return pyobj;
}


SWIGINTERN int BusinessRejectReason_UNKNID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_UNKNID is read-only.");
  return 1;
}


SWIGINTERN PyObject *BusinessRejectReason_UNKNID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_UNKNID));
  return pyobj;
}


SWIGINTERN int BusinessRejectReason_APPLICATION_NOT_AVAILABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_APPLICATION_NOT_AVAILABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 BusinessRejectReason_INVALID_PRICE_INCREMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_INVALID_PRICE_INCREMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 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 *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 BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 BusinessRejectReason_UNKNOWN_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_UNKNOWN_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *BusinessRejectReason_UNKNOWN_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_UNKNOWN_ID));
  return pyobj;
}


SWIGINTERN int BusinessRejectReason_NOTAUTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_NOTAUTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *BusinessRejectReason_NOTAUTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_NOTAUTH));
  return pyobj;
}


SWIGINTERN int BusinessRejectReason_NODELIVTOFIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_NODELIVTOFIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *BusinessRejectReason_NODELIVTOFIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_NODELIVTOFIRM));
  return pyobj;
}


SWIGINTERN int BusinessRejectReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *BusinessRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_OTHER));
  return pyobj;
}


SWIGINTERN int BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 BusinessRejectReason_UNKNOWN_MESSAGE_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_UNKNOWN_MESSAGE_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 BusinessRejectReason_NOT_AUTHORIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_NOT_AUTHORIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *BusinessRejectReason_NOT_AUTHORIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_NOT_AUTHORIZED));
  return pyobj;
}


SWIGINTERN int BusinessRejectReason_UNKNSEC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_UNKNSEC is read-only.");
  return 1;
}


SWIGINTERN PyObject *BusinessRejectReason_UNKNSEC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_UNKNSEC));
  return pyobj;
}


SWIGINTERN int BusinessRejectReason_UNKOWN_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_UNKOWN_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *BusinessRejectReason_UNKOWN_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_UNKOWN_ID));
  return pyobj;
}


SWIGINTERN int BookingType_REGULAR_BOOKING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BookingType_REGULAR_BOOKING is read-only.");
  return 1;
}


SWIGINTERN PyObject *BookingType_REGULAR_BOOKING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BookingType_REGULAR_BOOKING));
  return pyobj;
}


SWIGINTERN int BookingType_REGULARBOOKING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BookingType_REGULARBOOKING is read-only.");
  return 1;
}


SWIGINTERN PyObject *BookingType_REGULARBOOKING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BookingType_REGULARBOOKING));
  return pyobj;
}


SWIGINTERN int BookingType_CFD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BookingType_CFD is read-only.");
  return 1;
}


SWIGINTERN PyObject *BookingType_CFD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BookingType_CFD));
  return pyobj;
}


SWIGINTERN int BookingType_CFDCONTRACTFORDIFFERENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BookingType_CFDCONTRACTFORDIFFERENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *BookingType_CFDCONTRACTFORDIFFERENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BookingType_CFDCONTRACTFORDIFFERENCE));
  return pyobj;
}


SWIGINTERN int BookingType_TOTALRETURNSWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BookingType_TOTALRETURNSWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *BookingType_TOTALRETURNSWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BookingType_TOTALRETURNSWAP));
  return pyobj;
}


SWIGINTERN int BookingType_TOTAL_RETURN_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BookingType_TOTAL_RETURN_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::SessionID *result = 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::SessionID *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 4); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          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) {
            SWIG_PYTHON_THREAD_END_BLOCK;
            return _wrap_new_SessionID__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SessionID'.\n  Possible C/C++ prototypes are:\n    FIX::SessionID()\n    FIX::SessionID(std::string const &,std::string const &,std::string const &,std::string const &)\n    FIX::SessionID(std::string const &,std::string const &,std::string const &)\n");
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionID_getBeginString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  FIX::BeginString *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      FIX::BeginString const &_result_ref = ((FIX::SessionID const *)arg1)->getBeginString();
      result = (FIX::BeginString *) &_result_ref;
    }
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BeginString, 0 |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionID_getSenderCompID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  FIX::SenderCompID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      FIX::SenderCompID const &_result_ref = ((FIX::SessionID const *)arg1)->getSenderCompID();
      result = (FIX::SenderCompID *) &_result_ref;
    }
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SenderCompID, 0 |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionID_getTargetCompID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  FIX::TargetCompID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      FIX::TargetCompID const &_result_ref = ((FIX::SessionID const *)arg1)->getTargetCompID();
      result = (FIX::TargetCompID *) &_result_ref;
    }
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TargetCompID, 0 |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionID_getSessionQualifier(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      std::string const &_result_ref = ((FIX::SessionID const *)arg1)->getSessionQualifier();
      result = (std::string *) &_result_ref;
    }
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionID_isFIXT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionID_toString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  std::string result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionID_toStringFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      std::string const &_result_ref = ((FIX::SessionID const *)arg1)->toStringFrozen();
      result = (std::string *) &_result_ref;
    }
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      std::string &_result_ref = ((FIX::SessionID const *)arg1)->toString(*arg2);
      result = (std::string *) &_result_ref;
    }
    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()) );
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionID_toString(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_SessionID_toString__SWIG_1(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'SessionID_toString'.\n  Possible C/C++ prototypes are:\n    toString()\n    toString(std::string &)\n");
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionID___invert__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  FIX::SessionID result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionID___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  std::string result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap___lt__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); 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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap___lt____SWIG_1(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap___eq__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); 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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap___eq____SWIG_1(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap___ne__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); 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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap___ne____SWIG_1(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
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 ;
  std::ostream *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      std::ostream &_result_ref = FIX::operator <<(*arg1,(FIX::SessionID const &)*arg2);
      result = (std::ostream *) &_result_ref;
    }
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap___rshift____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::istream *arg1 = 0 ;
  FIX::SessionID *arg2 = 0 ;
  std::istream *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      std::istream &_result_ref = FIX::operator >>(*arg1,*arg2);
      result = (std::istream *) &_result_ref;
    }
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__istream, 0 |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dictionary__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::Dictionary *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dictionary__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dictionary(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_Dictionary__SWIG_0(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Dictionary'.\n  Possible C/C++ prototypes are:\n    FIX::Dictionary(std::string const &)\n    FIX::Dictionary()\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  std::string result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  std::string result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = ((FIX::Dictionary const *)arg1)->getString((std::string const &)*arg2,arg3);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  std::string result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = ((FIX::Dictionary const *)arg1)->getString((std::string const &)*arg2);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_getString(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 3); 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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          return _wrap_Dictionary_getString__SWIG_0(self, args);
        }
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Dictionary_getString'.\n  Possible C/C++ prototypes are:\n    getString(std::string const &,bool)\n    getString(std::string const &)\n");
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_getLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  std::string *arg2 = 0 ;
  long result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (long)((FIX::Dictionary const *)arg1)->getLong((std::string const &)*arg2);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  double result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (double)((FIX::Dictionary const *)arg1)->getDouble((std::string const &)*arg2);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (bool)((FIX::Dictionary const *)arg1)->getBool((std::string const &)*arg2);
    }
    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;
    }
    
    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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (int)((FIX::Dictionary const *)arg1)->getDay((std::string const &)*arg2);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  FIX::Dictionary::iterator result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  FIX::Dictionary::iterator result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 BEGINSTRING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BEGINSTRING is read-only.");
  return 1;
}


SWIGINTERN PyObject *BEGINSTRING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BEGINSTRING);
  return pyobj;
}


SWIGINTERN int SENDERCOMPID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SENDERCOMPID is read-only.");
  return 1;
}


SWIGINTERN PyObject *SENDERCOMPID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SENDERCOMPID);
  return pyobj;
}


SWIGINTERN int TARGETCOMPID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TARGETCOMPID is read-only.");
  return 1;
}


SWIGINTERN PyObject *TARGETCOMPID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TARGETCOMPID);
  return pyobj;
}


SWIGINTERN int SESSION_QUALIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SESSION_QUALIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *SESSION_QUALIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SESSION_QUALIFIER);
  return pyobj;
}


SWIGINTERN int DEFAULT_APPLVERID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DEFAULT_APPLVERID is read-only.");
  return 1;
}


SWIGINTERN PyObject *DEFAULT_APPLVERID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DEFAULT_APPLVERID);
  return pyobj;
}


SWIGINTERN int CONNECTION_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CONNECTION_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *CONNECTION_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CONNECTION_TYPE);
  return pyobj;
}


SWIGINTERN int USE_DATA_DICTIONARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable USE_DATA_DICTIONARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *USE_DATA_DICTIONARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::USE_DATA_DICTIONARY);
  return pyobj;
}


SWIGINTERN int SEND_RESETSEQNUMFLAG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SEND_RESETSEQNUMFLAG is read-only.");
  return 1;
}


SWIGINTERN PyObject *SEND_RESETSEQNUMFLAG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SEND_RESETSEQNUMFLAG);
  return pyobj;
}


SWIGINTERN int SEND_REDUNDANT_RESENDREQUESTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SEND_REDUNDANT_RESENDREQUESTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *SEND_REDUNDANT_RESENDREQUESTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SEND_REDUNDANT_RESENDREQUESTS);
  return pyobj;
}


SWIGINTERN int DATA_DICTIONARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DATA_DICTIONARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *DATA_DICTIONARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DATA_DICTIONARY);
  return pyobj;
}


SWIGINTERN int TRANSPORT_DATA_DICTIONARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TRANSPORT_DATA_DICTIONARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *TRANSPORT_DATA_DICTIONARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TRANSPORT_DATA_DICTIONARY);
  return pyobj;
}


SWIGINTERN int APP_DATA_DICTIONARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable APP_DATA_DICTIONARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *APP_DATA_DICTIONARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::APP_DATA_DICTIONARY);
  return pyobj;
}


SWIGINTERN int USE_LOCAL_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable USE_LOCAL_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *USE_LOCAL_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::USE_LOCAL_TIME);
  return pyobj;
}


SWIGINTERN int START_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable START_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *START_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::START_TIME);
  return pyobj;
}


SWIGINTERN int END_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable END_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *END_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::END_TIME);
  return pyobj;
}


SWIGINTERN int START_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable START_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *START_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::START_DAY);
  return pyobj;
}


SWIGINTERN int END_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable END_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *END_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::END_DAY);
  return pyobj;
}


SWIGINTERN int LOGON_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LOGON_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *LOGON_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::LOGON_TIME);
  return pyobj;
}


SWIGINTERN int LOGOUT_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LOGOUT_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *LOGOUT_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::LOGOUT_TIME);
  return pyobj;
}


SWIGINTERN int LOGON_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LOGON_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *LOGON_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::LOGON_DAY);
  return pyobj;
}


SWIGINTERN int LOGOUT_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LOGOUT_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *LOGOUT_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::LOGOUT_DAY);
  return pyobj;
}


SWIGINTERN int CHECK_COMPID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CHECK_COMPID is read-only.");
  return 1;
}


SWIGINTERN PyObject *CHECK_COMPID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CHECK_COMPID);
  return pyobj;
}


SWIGINTERN int CHECK_LATENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CHECK_LATENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *CHECK_LATENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CHECK_LATENCY);
  return pyobj;
}


SWIGINTERN int MAX_LATENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MAX_LATENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *MAX_LATENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MAX_LATENCY);
  return pyobj;
}


SWIGINTERN int HEARTBTINT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HEARTBTINT is read-only.");
  return 1;
}


SWIGINTERN PyObject *HEARTBTINT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::HEARTBTINT);
  return pyobj;
}


SWIGINTERN int SOCKET_ACCEPT_PORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SOCKET_ACCEPT_PORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SOCKET_ACCEPT_PORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SOCKET_ACCEPT_PORT);
  return pyobj;
}


SWIGINTERN int SOCKET_REUSE_ADDRESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SOCKET_REUSE_ADDRESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *SOCKET_REUSE_ADDRESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SOCKET_REUSE_ADDRESS);
  return pyobj;
}


SWIGINTERN int SOCKET_CONNECT_HOST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SOCKET_CONNECT_HOST is read-only.");
  return 1;
}


SWIGINTERN PyObject *SOCKET_CONNECT_HOST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SOCKET_CONNECT_HOST);
  return pyobj;
}


SWIGINTERN int SOCKET_CONNECT_PORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SOCKET_CONNECT_PORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *SOCKET_CONNECT_PORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SOCKET_CONNECT_PORT);
  return pyobj;
}


SWIGINTERN int SOCKET_NODELAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SOCKET_NODELAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *SOCKET_NODELAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SOCKET_NODELAY);
  return pyobj;
}


SWIGINTERN int SOCKET_SEND_BUFFER_SIZE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SOCKET_SEND_BUFFER_SIZE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SOCKET_SEND_BUFFER_SIZE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SOCKET_SEND_BUFFER_SIZE);
  return pyobj;
}


SWIGINTERN int SOCKET_RECEIVE_BUFFER_SIZE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SOCKET_RECEIVE_BUFFER_SIZE is read-only.");
  return 1;
}


SWIGINTERN PyObject *SOCKET_RECEIVE_BUFFER_SIZE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SOCKET_RECEIVE_BUFFER_SIZE);
  return pyobj;
}


SWIGINTERN int RECONNECT_INTERVAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RECONNECT_INTERVAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *RECONNECT_INTERVAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::RECONNECT_INTERVAL);
  return pyobj;
}


SWIGINTERN int VALIDATE_FIELDS_OUT_OF_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VALIDATE_FIELDS_OUT_OF_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *VALIDATE_FIELDS_OUT_OF_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::VALIDATE_FIELDS_OUT_OF_ORDER);
  return pyobj;
}


SWIGINTERN int VALIDATE_FIELDS_HAVE_VALUES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VALIDATE_FIELDS_HAVE_VALUES is read-only.");
  return 1;
}


SWIGINTERN PyObject *VALIDATE_FIELDS_HAVE_VALUES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::VALIDATE_FIELDS_HAVE_VALUES);
  return pyobj;
}


SWIGINTERN int VALIDATE_USER_DEFINED_FIELDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VALIDATE_USER_DEFINED_FIELDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *VALIDATE_USER_DEFINED_FIELDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::VALIDATE_USER_DEFINED_FIELDS);
  return pyobj;
}


SWIGINTERN int LOGON_TIMEOUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LOGON_TIMEOUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *LOGON_TIMEOUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::LOGON_TIMEOUT);
  return pyobj;
}


SWIGINTERN int LOGOUT_TIMEOUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LOGOUT_TIMEOUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *LOGOUT_TIMEOUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::LOGOUT_TIMEOUT);
  return pyobj;
}


SWIGINTERN int FILE_STORE_PATH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FILE_STORE_PATH is read-only.");
  return 1;
}


SWIGINTERN PyObject *FILE_STORE_PATH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::FILE_STORE_PATH);
  return pyobj;
}


SWIGINTERN int MYSQL_STORE_USECONNECTIONPOOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_STORE_USECONNECTIONPOOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *MYSQL_STORE_USECONNECTIONPOOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_STORE_USECONNECTIONPOOL);
  return pyobj;
}


SWIGINTERN int MYSQL_STORE_DATABASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_STORE_DATABASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MYSQL_STORE_DATABASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_STORE_DATABASE);
  return pyobj;
}


SWIGINTERN int MYSQL_STORE_USER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_STORE_USER is read-only.");
  return 1;
}


SWIGINTERN PyObject *MYSQL_STORE_USER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_STORE_USER);
  return pyobj;
}


SWIGINTERN int MYSQL_STORE_PASSWORD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_STORE_PASSWORD is read-only.");
  return 1;
}


SWIGINTERN PyObject *MYSQL_STORE_PASSWORD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_STORE_PASSWORD);
  return pyobj;
}


SWIGINTERN int MYSQL_STORE_HOST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_STORE_HOST is read-only.");
  return 1;
}


SWIGINTERN PyObject *MYSQL_STORE_HOST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_STORE_HOST);
  return pyobj;
}


SWIGINTERN int MYSQL_STORE_PORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_STORE_PORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *MYSQL_STORE_PORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_STORE_PORT);
  return pyobj;
}


SWIGINTERN int POSTGRESQL_STORE_USECONNECTIONPOOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_STORE_USECONNECTIONPOOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *POSTGRESQL_STORE_USECONNECTIONPOOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_STORE_USECONNECTIONPOOL);
  return pyobj;
}


SWIGINTERN int POSTGRESQL_STORE_DATABASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_STORE_DATABASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *POSTGRESQL_STORE_DATABASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_STORE_DATABASE);
  return pyobj;
}


SWIGINTERN int POSTGRESQL_STORE_USER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_STORE_USER is read-only.");
  return 1;
}


SWIGINTERN PyObject *POSTGRESQL_STORE_USER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_STORE_USER);
  return pyobj;
}


SWIGINTERN int POSTGRESQL_STORE_PASSWORD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_STORE_PASSWORD is read-only.");
  return 1;
}


SWIGINTERN PyObject *POSTGRESQL_STORE_PASSWORD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_STORE_PASSWORD);
  return pyobj;
}


SWIGINTERN int POSTGRESQL_STORE_HOST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_STORE_HOST is read-only.");
  return 1;
}


SWIGINTERN PyObject *POSTGRESQL_STORE_HOST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_STORE_HOST);
  return pyobj;
}


SWIGINTERN int POSTGRESQL_STORE_PORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_STORE_PORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *POSTGRESQL_STORE_PORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_STORE_PORT);
  return pyobj;
}


SWIGINTERN int ODBC_STORE_USER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ODBC_STORE_USER is read-only.");
  return 1;
}


SWIGINTERN PyObject *ODBC_STORE_USER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ODBC_STORE_USER);
  return pyobj;
}


SWIGINTERN int ODBC_STORE_PASSWORD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ODBC_STORE_PASSWORD is read-only.");
  return 1;
}


SWIGINTERN PyObject *ODBC_STORE_PASSWORD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ODBC_STORE_PASSWORD);
  return pyobj;
}


SWIGINTERN int ODBC_STORE_CONNECTION_STRING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ODBC_STORE_CONNECTION_STRING is read-only.");
  return 1;
}


SWIGINTERN PyObject *ODBC_STORE_CONNECTION_STRING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ODBC_STORE_CONNECTION_STRING);
  return pyobj;
}


SWIGINTERN int FILE_LOG_PATH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FILE_LOG_PATH is read-only.");
  return 1;
}


SWIGINTERN PyObject *FILE_LOG_PATH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::FILE_LOG_PATH);
  return pyobj;
}


SWIGINTERN int FILE_LOG_BACKUP_PATH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FILE_LOG_BACKUP_PATH is read-only.");
  return 1;
}


SWIGINTERN PyObject *FILE_LOG_BACKUP_PATH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::FILE_LOG_BACKUP_PATH);
  return pyobj;
}


SWIGINTERN int SCREEN_LOG_SHOW_INCOMING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SCREEN_LOG_SHOW_INCOMING is read-only.");
  return 1;
}


SWIGINTERN PyObject *SCREEN_LOG_SHOW_INCOMING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SCREEN_LOG_SHOW_INCOMING);
  return pyobj;
}


SWIGINTERN int SCREEN_LOG_SHOW_OUTGOING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SCREEN_LOG_SHOW_OUTGOING is read-only.");
  return 1;
}


SWIGINTERN PyObject *SCREEN_LOG_SHOW_OUTGOING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SCREEN_LOG_SHOW_OUTGOING);
  return pyobj;
}


SWIGINTERN int SCREEN_LOG_SHOW_EVENTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SCREEN_LOG_SHOW_EVENTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *SCREEN_LOG_SHOW_EVENTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SCREEN_LOG_SHOW_EVENTS);
  return pyobj;
}


SWIGINTERN int MYSQL_LOG_USECONNECTIONPOOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_LOG_USECONNECTIONPOOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *MYSQL_LOG_USECONNECTIONPOOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_LOG_USECONNECTIONPOOL);
  return pyobj;
}


SWIGINTERN int MYSQL_LOG_DATABASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_LOG_DATABASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MYSQL_LOG_DATABASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_LOG_DATABASE);
  return pyobj;
}


SWIGINTERN int MYSQL_LOG_USER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_LOG_USER is read-only.");
  return 1;
}


SWIGINTERN PyObject *MYSQL_LOG_USER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_LOG_USER);
  return pyobj;
}


SWIGINTERN int MYSQL_LOG_PASSWORD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_LOG_PASSWORD is read-only.");
  return 1;
}


SWIGINTERN PyObject *MYSQL_LOG_PASSWORD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_LOG_PASSWORD);
  return pyobj;
}


SWIGINTERN int MYSQL_LOG_HOST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_LOG_HOST is read-only.");
  return 1;
}


SWIGINTERN PyObject *MYSQL_LOG_HOST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_LOG_HOST);
  return pyobj;
}


SWIGINTERN int MYSQL_LOG_PORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_LOG_PORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *MYSQL_LOG_PORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_LOG_PORT);
  return pyobj;
}


SWIGINTERN int MYSQL_LOG_INCOMING_TABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_LOG_INCOMING_TABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MYSQL_LOG_INCOMING_TABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_LOG_INCOMING_TABLE);
  return pyobj;
}


SWIGINTERN int MYSQL_LOG_OUTGOING_TABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_LOG_OUTGOING_TABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MYSQL_LOG_OUTGOING_TABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_LOG_OUTGOING_TABLE);
  return pyobj;
}


SWIGINTERN int MYSQL_LOG_EVENT_TABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_LOG_EVENT_TABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *MYSQL_LOG_EVENT_TABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_LOG_EVENT_TABLE);
  return pyobj;
}


SWIGINTERN int POSTGRESQL_LOG_USECONNECTIONPOOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_LOG_USECONNECTIONPOOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *POSTGRESQL_LOG_USECONNECTIONPOOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_USECONNECTIONPOOL);
  return pyobj;
}


SWIGINTERN int POSTGRESQL_LOG_DATABASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_LOG_DATABASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *POSTGRESQL_LOG_DATABASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_DATABASE);
  return pyobj;
}


SWIGINTERN int POSTGRESQL_LOG_USER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_LOG_USER is read-only.");
  return 1;
}


SWIGINTERN PyObject *POSTGRESQL_LOG_USER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_USER);
  return pyobj;
}


SWIGINTERN int POSTGRESQL_LOG_PASSWORD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_LOG_PASSWORD is read-only.");
  return 1;
}


SWIGINTERN PyObject *POSTGRESQL_LOG_PASSWORD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_PASSWORD);
  return pyobj;
}


SWIGINTERN int POSTGRESQL_LOG_HOST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_LOG_HOST is read-only.");
  return 1;
}


SWIGINTERN PyObject *POSTGRESQL_LOG_HOST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_HOST);
  return pyobj;
}


SWIGINTERN int POSTGRESQL_LOG_PORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_LOG_PORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *POSTGRESQL_LOG_PORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_PORT);
  return pyobj;
}


SWIGINTERN int POSTGRESQL_LOG_INCOMING_TABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_LOG_INCOMING_TABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *POSTGRESQL_LOG_INCOMING_TABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_INCOMING_TABLE);
  return pyobj;
}


SWIGINTERN int POSTGRESQL_LOG_OUTGOING_TABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_LOG_OUTGOING_TABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *POSTGRESQL_LOG_OUTGOING_TABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_OUTGOING_TABLE);
  return pyobj;
}


SWIGINTERN int POSTGRESQL_LOG_EVENT_TABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_LOG_EVENT_TABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *POSTGRESQL_LOG_EVENT_TABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_EVENT_TABLE);
  return pyobj;
}


SWIGINTERN int ODBC_LOG_USER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ODBC_LOG_USER is read-only.");
  return 1;
}


SWIGINTERN PyObject *ODBC_LOG_USER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ODBC_LOG_USER);
  return pyobj;
}


SWIGINTERN int ODBC_LOG_PASSWORD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ODBC_LOG_PASSWORD is read-only.");
  return 1;
}


SWIGINTERN PyObject *ODBC_LOG_PASSWORD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ODBC_LOG_PASSWORD);
  return pyobj;
}


SWIGINTERN int ODBC_LOG_CONNECTION_STRING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ODBC_LOG_CONNECTION_STRING is read-only.");
  return 1;
}


SWIGINTERN PyObject *ODBC_LOG_CONNECTION_STRING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ODBC_LOG_CONNECTION_STRING);
  return pyobj;
}


SWIGINTERN int ODBC_LOG_INCOMING_TABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ODBC_LOG_INCOMING_TABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ODBC_LOG_INCOMING_TABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ODBC_LOG_INCOMING_TABLE);
  return pyobj;
}


SWIGINTERN int ODBC_LOG_OUTGOING_TABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ODBC_LOG_OUTGOING_TABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ODBC_LOG_OUTGOING_TABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ODBC_LOG_OUTGOING_TABLE);
  return pyobj;
}


SWIGINTERN int ODBC_LOG_EVENT_TABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ODBC_LOG_EVENT_TABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *ODBC_LOG_EVENT_TABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ODBC_LOG_EVENT_TABLE);
  return pyobj;
}


SWIGINTERN int RESET_ON_LOGON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RESET_ON_LOGON is read-only.");
  return 1;
}


SWIGINTERN PyObject *RESET_ON_LOGON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::RESET_ON_LOGON);
  return pyobj;
}


SWIGINTERN int RESET_ON_LOGOUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RESET_ON_LOGOUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *RESET_ON_LOGOUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::RESET_ON_LOGOUT);
  return pyobj;
}


SWIGINTERN int RESET_ON_DISCONNECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RESET_ON_DISCONNECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *RESET_ON_DISCONNECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::RESET_ON_DISCONNECT);
  return pyobj;
}


SWIGINTERN int REFRESH_ON_LOGON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable REFRESH_ON_LOGON is read-only.");
  return 1;
}


SWIGINTERN PyObject *REFRESH_ON_LOGON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::REFRESH_ON_LOGON);
  return pyobj;
}


SWIGINTERN int MILLISECONDS_IN_TIMESTAMP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MILLISECONDS_IN_TIMESTAMP is read-only.");
  return 1;
}


SWIGINTERN PyObject *MILLISECONDS_IN_TIMESTAMP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MILLISECONDS_IN_TIMESTAMP);
  return pyobj;
}


SWIGINTERN int HTTP_ACCEPT_PORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HTTP_ACCEPT_PORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *HTTP_ACCEPT_PORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::HTTP_ACCEPT_PORT);
  return pyobj;
}


SWIGINTERN int PERSIST_MESSAGES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PERSIST_MESSAGES is read-only.");
  return 1;
}


SWIGINTERN PyObject *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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionSettings__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::istream *arg1 = 0 ;
  FIX::SessionSettings *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (FIX::SessionSettings *)new FIX::SessionSettings(*arg1);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SessionSettings, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionSettings__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::SessionSettings *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (FIX::SessionSettings *)new FIX::SessionSettings((std::string const &)*arg1);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionSettings(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_SessionSettings__SWIG_2(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SessionSettings'.\n  Possible C/C++ prototypes are:\n    FIX::SessionSettings()\n    FIX::SessionSettings(std::istream &)\n    FIX::SessionSettings(std::string const &)\n");
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionSettings_has(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionSettings *arg1 = (FIX::SessionSettings *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::Dictionary *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      {
        FIX::Dictionary const &_result_ref = ((FIX::SessionSettings const *)arg1)->get((FIX::SessionID const &)*arg2);
        result = (FIX::Dictionary *) &_result_ref;
      }
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->set((FIX::SessionID const &)*arg2,arg3);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionSettings_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionSettings *arg1 = (FIX::SessionSettings *) 0 ;
  FIX::Dictionary *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      FIX::Dictionary const &_result_ref = ((FIX::SessionSettings const *)arg1)->get();
      result = (FIX::Dictionary *) &_result_ref;
    }
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionSettings_get(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_SessionSettings_get__SWIG_0(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'SessionSettings_get'.\n  Possible C/C++ prototypes are:\n    get(FIX::SessionID const &)\n    get()\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->set((FIX::Dictionary const &)*arg2);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionSettings_set(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 3); 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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          return _wrap_SessionSettings_set__SWIG_0(self, args);
        }
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'SessionSettings_set'.\n  Possible C/C++ prototypes are:\n    set(FIX::SessionID const &,FIX::Dictionary)\n    set(FIX::Dictionary const &)\n");
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionSettings_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionSettings *arg1 = (FIX::SessionSettings *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionSettings_getSessions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionSettings *arg1 = (FIX::SessionSettings *) 0 ;
  SwigValueWrapper<std::set<FIX::SessionID > > result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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__setTFIX__SessionID_t, SWIG_POINTER_OWN |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  std::istream *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      {
        std::istream &_result_ref = FIX::operator >>(*arg1,*arg2);
        result = (std::istream *) &_result_ref;
      }
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__istream, 0 |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap___rshift__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); 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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap___rshift____SWIG_1(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
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 ;
  std::ostream *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      std::ostream &_result_ref = FIX::operator <<(*arg1,(FIX::SessionSettings const &)*arg2);
      result = (std::ostream *) &_result_ref;
    }
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap___lshift__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); 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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap___lshift____SWIG_3(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
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 ;
  FIX::Session *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_logout(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_Session_logout__SWIG_0(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Session_logout'.\n  Possible C/C++ prototypes are:\n    logout(std::string const &)\n    logout()\n");
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_isEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_sentLogon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_sentLogout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_receivedLogon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_isLoggedOn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->reset();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->refresh();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->setNextSenderMsgSeqNum(arg2);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->setNextTargetMsgSeqNum(arg2);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getSessionID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  FIX::SessionID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      FIX::SessionID const &_result_ref = ((FIX::Session const *)arg1)->getSessionID();
      result = (FIX::SessionID *) &_result_ref;
    }
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SessionID, 0 |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getDataDictionaryProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  DataDictionaryProvider *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      DataDictionaryProvider const &_result_ref = ((FIX::Session const *)arg1)->getDataDictionaryProvider();
      result = (DataDictionaryProvider *) &_result_ref;
    }
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DataDictionaryProvider, 0 |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (bool)FIX::Session::sendToTarget(*arg1,(std::string const &)*arg2);
    }
    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;
    }
    
    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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_sendToTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (bool)FIX::Session::sendToTarget(*arg1);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (bool)FIX::Session::sendToTarget(*arg1,(FIX::SessionID const &)*arg2);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (bool)FIX::Session::sendToTarget(*arg1,(FIX::SenderCompID const &)*arg2,(FIX::TargetCompID const &)*arg3,(std::string const &)*arg4);
    }
    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;
    }
    
    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(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  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_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (bool)FIX::Session::sendToTarget(*arg1,(FIX::SenderCompID const &)*arg2,(FIX::TargetCompID const &)*arg3);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (bool)FIX::Session::sendToTarget(*arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4);
    }
    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;
    }
    
    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("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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (bool)FIX::Session::sendToTarget(*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    }
    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;
    }
    
    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("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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_sendToTarget(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 4); ii++) {
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          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) {
            SWIG_PYTHON_THREAD_END_BLOCK;
            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) {
            SWIG_PYTHON_THREAD_END_BLOCK;
            return _wrap_Session_sendToTarget__SWIG_5(self, args);
          }
        }
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Session_sendToTarget'.\n  Possible C/C++ prototypes are:\n    sendToTarget(FIX::Message &,std::string const &)\n    sendToTarget(FIX::Message &)\n    sendToTarget(FIX::Message &,FIX::SessionID const &)\n    sendToTarget(FIX::Message &,FIX::SenderCompID const &,FIX::TargetCompID const &,std::string const &)\n    sendToTarget(FIX::Message &,FIX::SenderCompID const &,FIX::TargetCompID const &)\n    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 NULL;
}


SWIGINTERN PyObject *_wrap_Session_getSessions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper<std::set<FIX::SessionID > > result;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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__setTFIX__SessionID_t, SWIG_POINTER_OWN |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_doesSessionExist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_lookupSession__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = 0 ;
  FIX::Session *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_lookupSession__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  bool arg2 ;
  FIX::Session *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_lookupSession__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::Session *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_lookupSession(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); 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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_Session_lookupSession__SWIG_1(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Session_lookupSession'.\n  Possible C/C++ prototypes are:\n    lookupSession(FIX::SessionID const &)\n    lookupSession(std::string const &,bool)\n    FIX::Session::lookupSession(std::string const &)\n");
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_isSessionRegistered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_registerSession(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = 0 ;
  FIX::Session *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_numSessions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_isSessionTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  DateTime *arg2 = 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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_DateTime,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Session_isSessionTime" "', argument " "2"" of type '" "DateTime const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_isSessionTime" "', argument " "2"" of type '" "DateTime const &""'"); 
  }
  arg2 = reinterpret_cast< DateTime * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->isSessionTime((DateTime const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_isLogonTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  DateTime *arg2 = 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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_DateTime,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Session_isLogonTime" "', argument " "2"" of type '" "DateTime const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_isLogonTime" "', argument " "2"" of type '" "DateTime const &""'"); 
  }
  arg2 = reinterpret_cast< DateTime * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->isLogonTime((DateTime const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_isInitiator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_isAcceptor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getLogonTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  TimeRange *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      TimeRange const &_result_ref = (arg1)->getLogonTime();
      result = (TimeRange *) &_result_ref;
    }
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TimeRange, 0 |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getSenderDefaultApplVerID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      std::string const &_result_ref = (arg1)->getSenderDefaultApplVerID();
      result = (std::string *) &_result_ref;
    }
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getTargetDefaultApplVerID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      std::string const &_result_ref = (arg1)->getTargetDefaultApplVerID();
      result = (std::string *) &_result_ref;
    }
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getSendRedundantResendRequests(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getCheckCompId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getCheckLatency(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getMaxLatency(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getLogonTimeout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getLogoutTimeout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getResetOnLogon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getResetOnLogout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getResetOnDisconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getRefreshOnLogon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getMillisecondsInTimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getPersistMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_next(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 4); ii++) {
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          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) {
            SWIG_PYTHON_THREAD_END_BLOCK;
            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) {
            SWIG_PYTHON_THREAD_END_BLOCK;
            return _wrap_Session_next__SWIG_2(self, args);
          }
        }
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Session_next'.\n  Possible C/C++ prototypes are:\n    next()\n    next(UtcTimeStamp const &)\n    next(std::string const &,UtcTimeStamp const &,bool)\n    next(std::string const &,UtcTimeStamp const &)\n    next(FIX::Message const &,UtcTimeStamp const &,bool)\n    next(FIX::Message const &,UtcTimeStamp const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getExpectedSenderNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  long result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getExpectedTargetNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  long result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  Log *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getStore(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  MessageStore *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogFactory_create__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LogFactory *arg1 = (FIX::LogFactory *) 0 ;
  FIX::Log *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::Log *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogFactory_create(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_LogFactory_create__SWIG_1(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'LogFactory_create'.\n  Possible C/C++ prototypes are:\n    create()\n    create(FIX::SessionID const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::ScreenLogFactory *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScreenLogFactory__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool arg2 ;
  bool arg3 ;
  FIX::ScreenLogFactory *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScreenLogFactory(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 3); 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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          return _wrap_new_ScreenLogFactory__SWIG_1(self, args);
        }
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ScreenLogFactory'.\n  Possible C/C++ prototypes are:\n    FIX::ScreenLogFactory(FIX::SessionSettings const &)\n    FIX::ScreenLogFactory(bool,bool,bool)\n");
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScreenLogFactory_create__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ScreenLogFactory *arg1 = (FIX::ScreenLogFactory *) 0 ;
  FIX::Log *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::Log *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScreenLogFactory_create(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_ScreenLogFactory_create__SWIG_1(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ScreenLogFactory_create'.\n  Possible C/C++ prototypes are:\n    create()\n    create(FIX::SessionID const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NullLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullLog *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::ScreenLog *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::ScreenLog *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScreenLog(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 4); 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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          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) {
            SWIG_PYTHON_THREAD_END_BLOCK;
            return _wrap_new_ScreenLog__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ScreenLog'.\n  Possible C/C++ prototypes are:\n    FIX::ScreenLog(bool,bool,bool)\n    FIX::ScreenLog(FIX::SessionID const &,bool,bool,bool)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScreenLog_getMillisecondsInTimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ScreenLog *arg1 = (FIX::ScreenLog *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::FileLogFactory *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FileLogFactory__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::FileLogFactory *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::FileLogFactory *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FileLogFactory(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); 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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_new_FileLogFactory__SWIG_2(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_FileLogFactory'.\n  Possible C/C++ prototypes are:\n    FIX::FileLogFactory(FIX::SessionSettings const &)\n    FIX::FileLogFactory(std::string const &)\n    FIX::FileLogFactory(std::string const &,std::string const &)\n");
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileLogFactory_create__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileLogFactory *arg1 = (FIX::FileLogFactory *) 0 ;
  FIX::Log *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::Log *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileLogFactory_create(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_FileLogFactory_create__SWIG_1(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FileLogFactory_create'.\n  Possible C/C++ prototypes are:\n    create()\n    create(FIX::SessionID const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::FileLog *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::FileLog *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::FileLog *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FileLog(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 3); 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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          return _wrap_new_FileLog__SWIG_2(self, args);
        }
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_FileLog'.\n  Possible C/C++ prototypes are:\n    FIX::FileLog(std::string const &)\n    FIX::FileLog(std::string const &,FIX::SessionID const &)\n    FIX::FileLog(std::string const &,std::string const &,FIX::SessionID const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileLog_getMillisecondsInTimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileLog *arg1 = (FIX::FileLog *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::MessageStore *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::MessageStore *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MemoryStoreFactory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStoreFactory *result = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (bool)(arg1)->set(arg2,(std::string const &)*arg3);
    }
    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;
    }
    
    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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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__vectorTstd__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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      ((FIX::MessageStore const *)arg1)->get(arg2,arg3,*arg4);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStore_getNextSenderMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (int)((FIX::MessageStore const *)arg1)->getNextSenderMsgSeqNum();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStore_getNextTargetMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (int)((FIX::MessageStore const *)arg1)->getNextTargetMsgSeqNum();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->setNextSenderMsgSeqNum(arg2);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->setNextTargetMsgSeqNum(arg2);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->incrNextSenderMsgSeqNum();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->incrNextTargetMsgSeqNum();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStore_getCreationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  UtcTimeStamp result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = ((FIX::MessageStore const *)arg1)->getCreationTime();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new UtcTimeStamp(static_cast< const UtcTimeStamp& >(result))), SWIGTYPE_p_UtcTimeStamp, SWIG_POINTER_OWN |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->reset();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->refresh();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (bool)(arg1)->set(arg2,(std::string const &)*arg3);
    }
    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;
    }
    
    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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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__vectorTstd__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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      ((FIX::MemoryStore const *)arg1)->get(arg2,arg3,*arg4);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MemoryStore_getNextSenderMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (int)((FIX::MemoryStore const *)arg1)->getNextSenderMsgSeqNum();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MemoryStore_getNextTargetMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (int)((FIX::MemoryStore const *)arg1)->getNextTargetMsgSeqNum();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->setNextSenderMsgSeqNum(arg2);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->setNextTargetMsgSeqNum(arg2);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->incrNextSenderMsgSeqNum();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->incrNextTargetMsgSeqNum();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->setCreationTime((UtcTimeStamp const &)*arg2);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MemoryStore_getCreationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  UtcTimeStamp result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = ((FIX::MemoryStore const *)arg1)->getCreationTime();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new UtcTimeStamp(static_cast< const UtcTimeStamp& >(result))), SWIGTYPE_p_UtcTimeStamp, SWIG_POINTER_OWN |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->reset();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->refresh();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::MessageStoreFactoryExceptionWrapper *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::MessageStore *result = 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::MessageStoreExceptionWrapper *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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__vectorTstd__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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  int result;
  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_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  int result;
  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_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  UtcTimeStamp result;
  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_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::FileStoreFactory *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FileStoreFactory__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::FileStoreFactory *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FileStoreFactory(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); 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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_FileStoreFactory__SWIG_1(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_FileStoreFactory'.\n  Possible C/C++ prototypes are:\n    FIX::FileStoreFactory(FIX::SessionSettings const &)\n    FIX::FileStoreFactory(std::string const &)\n");
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileStoreFactory_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStoreFactory *arg1 = (FIX::FileStoreFactory *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  FIX::MessageStore *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::FileStore *result = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (bool)(arg1)->set(arg2,(std::string const &)*arg3);
    }
    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;
    }
    
    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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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__vectorTstd__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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      ((FIX::FileStore const *)arg1)->get(arg2,arg3,*arg4);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileStore_getNextSenderMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (int)((FIX::FileStore const *)arg1)->getNextSenderMsgSeqNum();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileStore_getNextTargetMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (int)((FIX::FileStore const *)arg1)->getNextTargetMsgSeqNum();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->setNextSenderMsgSeqNum(arg2);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->setNextTargetMsgSeqNum(arg2);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->incrNextSenderMsgSeqNum();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->incrNextTargetMsgSeqNum();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileStore_getCreationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  UtcTimeStamp result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = ((FIX::FileStore const *)arg1)->getCreationTime();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new UtcTimeStamp(static_cast< const UtcTimeStamp& >(result))), SWIGTYPE_p_UtcTimeStamp, SWIG_POINTER_OWN |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->reset();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->refresh();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Application(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  FIX::Application *result = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 = dynamic_cast<Swig::Director *>(arg1);
      if (director) director->swig_disown();
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::SynchronizedApplication *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SynchronizedApplication_m_mutex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  Mutex result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SynchronizedApplication_app(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  FIX::Application *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      FIX::Application &_result_ref = (arg1)->app();
      result = (FIX::Application *) &_result_ref;
    }
    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 );
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SynchronizedApplication_m_app_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  FIX::Application *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      FIX::Application &_result_ref = (FIX::Application &) ((arg1)->m_app);
      result = (FIX::Application *) &_result_ref;
    }
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Application, 0 |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->start();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->block();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (bool)(arg1)->poll(arg2);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_poll__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (bool)(arg1)->poll();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_poll(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_Initiator_poll__SWIG_0(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Initiator_poll'.\n  Possible C/C++ prototypes are:\n    poll(double)\n    poll()\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_stop(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_Initiator_stop__SWIG_0(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Initiator_stop'.\n  Possible C/C++ prototypes are:\n    stop(bool)\n    stop()\n");
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_isLoggedOn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::Session *result = 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_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_getSessions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  std::set<FIX::SessionID > *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      std::set<FIX::SessionID > const &_result_ref = ((FIX::Initiator const *)arg1)->getSessions();
      result = (std::set<FIX::SessionID > *) &_result_ref;
    }
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__setTFIX__SessionID_t, 0 |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::Session *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_getSession(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 3); 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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          return _wrap_Initiator_getSession__SWIG_0(self, args);
        }
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Initiator_getSession'.\n  Possible C/C++ prototypes are:\n    getSession(FIX::SessionID const &,Responder &)\n    getSession(FIX::SessionID const &)\n");
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_getSessionSettings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  FIX::Dictionary *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_isStopped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_getApplication(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  FIX::Application *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      FIX::Application &_result_ref = (arg1)->getApplication();
      result = (FIX::Application *) &_result_ref;
    }
    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 );
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_getMessageStoreFactory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  FIX::MessageStoreFactory *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      FIX::MessageStoreFactory &_result_ref = (arg1)->getMessageStoreFactory();
      result = (FIX::MessageStoreFactory *) &_result_ref;
    }
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageStoreFactory, 0 |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_getLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  FIX::Log *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::SocketInitiator *result = 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_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (FIX::SocketInitiator *)new FIX::SocketInitiator(*arg1,*arg2,(FIX::SessionSettings const &)*arg3);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SocketInitiator, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::SocketInitiator *result = 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (FIX::SocketInitiator *)new FIX::SocketInitiator(*arg1,*arg2,(FIX::SessionSettings const &)*arg3,*arg4);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SocketInitiator, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SocketInitiatorBase(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 4); 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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          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) {
            SWIG_PYTHON_THREAD_END_BLOCK;
            return _wrap_new_SocketInitiatorBase__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SocketInitiatorBase'.\n  Possible C/C++ prototypes are:\n    FIX::SocketInitiator(FIX::Application &,FIX::MessageStoreFactory &,FIX::SessionSettings const &)\n    FIX::SocketInitiator(FIX::Application &,FIX::MessageStoreFactory &,FIX::SessionSettings const &,FIX::LogFactory &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_getLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  FIX::Log *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->start();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->block();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (bool)(arg1)->poll(arg2);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_poll__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (bool)(arg1)->poll();
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_poll(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_Acceptor_poll__SWIG_0(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Acceptor_poll'.\n  Possible C/C++ prototypes are:\n    poll(double)\n    poll()\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_stop(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        return _wrap_Acceptor_stop__SWIG_0(self, args);
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Acceptor_stop'.\n  Possible C/C++ prototypes are:\n    stop(bool)\n    stop()\n");
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_isLoggedOn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::Session *result = 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_getSessions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  std::set<FIX::SessionID > *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      std::set<FIX::SessionID > const &_result_ref = ((FIX::Acceptor const *)arg1)->getSessions();
      result = (std::set<FIX::SessionID > *) &_result_ref;
    }
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__setTFIX__SessionID_t, 0 |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::Session *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_getSession(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 3); 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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          return _wrap_Acceptor_getSession__SWIG_0(self, args);
        }
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Acceptor_getSession'.\n  Possible C/C++ prototypes are:\n    getSession(std::string const &,Responder &)\n    getSession(FIX::SessionID const &)\n");
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_getSessionSettings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  FIX::Dictionary *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_isStopped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_getApplication(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  FIX::Application *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      FIX::Application &_result_ref = (arg1)->getApplication();
      result = (FIX::Application *) &_result_ref;
    }
    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 );
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_getMessageStoreFactory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  FIX::MessageStoreFactory *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    {
      FIX::MessageStoreFactory &_result_ref = (arg1)->getMessageStoreFactory();
      result = (FIX::MessageStoreFactory *) &_result_ref;
    }
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageStoreFactory, 0 |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::SocketAcceptor *result = 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_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (FIX::SocketAcceptor *)new FIX::SocketAcceptor(*arg1,*arg2,(FIX::SessionSettings const &)*arg3);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SocketAcceptor, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  FIX::SocketAcceptor *result = 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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (FIX::SocketAcceptor *)new FIX::SocketAcceptor(*arg1,*arg2,(FIX::SessionSettings const &)*arg3,*arg4);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SocketAcceptor, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SocketAcceptorBase(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 4); 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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          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) {
            SWIG_PYTHON_THREAD_END_BLOCK;
            return _wrap_new_SocketAcceptorBase__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SocketAcceptorBase'.\n  Possible C/C++ prototypes are:\n    FIX::SocketAcceptor(FIX::Application &,FIX::MessageStoreFactory &,FIX::SessionSettings const &)\n    FIX::SocketAcceptor(FIX::Application &,FIX::MessageStoreFactory &,FIX::SessionSettings const &,FIX::LogFactory &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DataDictionary__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = 0 ;
  FIX::DataDictionary *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DataDictionary__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::istream *arg1 = 0 ;
  FIX::DataDictionary *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (FIX::DataDictionary *)new FIX::DataDictionary(*arg1);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DataDictionary, SWIG_POINTER_NEW |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DataDictionary__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::DataDictionary *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      result = (FIX::DataDictionary *)new FIX::DataDictionary((std::string const &)*arg1);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DataDictionary(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    SWIG_PYTHON_THREAD_END_BLOCK;
    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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      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) {
      SWIG_PYTHON_THREAD_END_BLOCK;
      return _wrap_new_DataDictionary__SWIG_3(self, args);
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DataDictionary'.\n  Possible C/C++ prototypes are:\n    FIX::DataDictionary()\n    FIX::DataDictionary(FIX::DataDictionary const &)\n    FIX::DataDictionary(std::istream &)\n    FIX::DataDictionary(std::string const &)\n");
  return NULL;
}


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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->readFromURL((std::string const &)*arg2);
    }
    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;
    }
    
    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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->readFromDocument(arg2);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      (arg1)->readFromStream(*arg2);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_getOrderedFields(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  int *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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 = (int *)((FIX::DataDictionary const *)arg1)->getOrderedFields();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_getVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  std::string result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  std::string temp3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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()) );
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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) ); 	 
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_isField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  int arg2 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_isHeaderField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  int arg2 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_isTrailerField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  int arg2 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_hasFieldValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  int arg2 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  bool result;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_isDataField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  int arg2 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_isMultipleValueField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  int arg2 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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));
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      FIX::DataDictionary::validate((FIX::Message const &)*arg1,(FIX::DataDictionary const *)arg2,(FIX::DataDictionary const *)arg3);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      ((FIX::DataDictionary const *)arg1)->validate((FIX::Message const &)*arg2);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  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 ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  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);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    try {
      ((FIX::DataDictionary const *)arg1)->validate((FIX::Message const &)*arg2,arg3);
    }
    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;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  SWIG_PYTHON_THREAD_END_BLOCK;
  return resultobj;
fail:
  SWIG_PYTHON_THREAD_END_BLOCK;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_validate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = PyObject_Length(args);
  for (ii = 0; (ii < argc) && (ii < 3); 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) {
        SWIG_PYTHON_THREAD_END_BLOCK;
        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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          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) {
          SWIG_PYTHON_THREAD_END_BLOCK;
          return _wrap_DataDictionary_validate__SWIG_2(self, args);
        }
      }
    }
  }
  
  SWIG_PYTHON_THREAD_END_BLOCK;
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'DataDictionary_validate'.\n  Possible C/C++ prototypes are:\n    validate(FIX::Message const &,FIX::DataDictionary const *const,FIX::DataDictionary const *const)\n    validate(FIX::Message const &)\n    validate(FIX::Message const &,bool)\n");
  return NULL;
}


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 *)"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_getValue", _wrap_FieldBase_getValue, 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 *)"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_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_RelatedPartyID", _wrap_new_RelatedPartyID, METH_VARARGS, NULL},
	 { (char *)"delete_RelatedPartyID", _wrap_delete_RelatedPartyID, METH_VARARGS, NULL},
	 { (char *)"RelatedPartyID_swigregister", RelatedPartyID_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_RiskEncodedSecurityDesc", _wrap_new_RiskEncodedSecurityDesc, METH_VARARGS, NULL},
	 { (char *)"delete_RiskEncodedSecurityDesc", _wrap_delete_RiskEncodedSecurityDesc, METH_VARARGS, NULL},
	 { (char *)"RiskEncodedSecurityDesc_swigregister", RiskEncodedSecurityDesc_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RelationshipRiskSecuritySubType", _wrap_new_RelationshipRiskSecuritySubType, METH_VARARGS, NULL},
	 { (char *)"delete_RelationshipRiskSecuritySubType", _wrap_delete_RelationshipRiskSecuritySubType, METH_VARARGS, NULL},
	 { (char *)"RelationshipRiskSecuritySubType_swigregister", RelationshipRiskSecuritySubType_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_EncodedSymbolLen", _wrap_new_EncodedSymbolLen, METH_VARARGS, NULL},
	 { (char *)"delete_EncodedSymbolLen", _wrap_delete_EncodedSymbolLen, METH_VARARGS, NULL},
	 { (char *)"EncodedSymbolLen_swigregister", EncodedSymbolLen_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_PartyAltIDSource", _wrap_new_PartyAltIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_PartyAltIDSource", _wrap_delete_PartyAltIDSource, METH_VARARGS, NULL},
	 { (char *)"PartyAltIDSource_swigregister", PartyAltIDSource_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_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_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_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_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_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_NoRelatedPartyIDs", _wrap_new_NoRelatedPartyIDs, METH_VARARGS, NULL},
	 { (char *)"delete_NoRelatedPartyIDs", _wrap_delete_NoRelatedPartyIDs, METH_VARARGS, NULL},
	 { (char *)"NoRelatedPartyIDs_swigregister", NoRelatedPartyIDs_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_RelationshipRiskMaturityTime", _wrap_new_RelationshipRiskMaturityTime, METH_VARARGS, NULL},
	 { (char *)"delete_RelationshipRiskMaturityTime", _wrap_delete_RelationshipRiskMaturityTime, METH_VARARGS, NULL},
	 { (char *)"RelationshipRiskMaturityTime_swigregister", RelationshipRiskMaturityTime_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_RiskWarningLevelPercent", _wrap_new_RiskWarningLevelPercent, METH_VARARGS, NULL},
	 { (char *)"delete_RiskWarningLevelPercent", _wrap_delete_RiskWarningLevelPercent, METH_VARARGS, NULL},
	 { (char *)"RiskWarningLevelPercent_swigregister", RiskWarningLevelPercent_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_RiskWarningLevelName", _wrap_new_RiskWarningLevelName, METH_VARARGS, NULL},
	 { (char *)"delete_RiskWarningLevelName", _wrap_delete_RiskWarningLevelName, METH_VARARGS, NULL},
	 { (char *)"RiskWarningLevelName_swigregister", RiskWarningLevelName_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_NoRelationshipRiskLimits", _wrap_new_NoRelationshipRiskLimits, METH_VARARGS, NULL},
	 { (char *)"delete_NoRelationshipRiskLimits", _wrap_delete_NoRelationshipRiskLimits, METH_VARARGS, NULL},
	 { (char *)"NoRelationshipRiskLimits_swigregister", NoRelationshipRiskLimits_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_RelationshipRiskInstrumentOperator", _wrap_new_RelationshipRiskInstrumentOperator, METH_VARARGS, NULL},
	 { (char *)"delete_RelationshipRiskInstrumentOperator", _wrap_delete_RelationshipRiskInstrumentOperator, METH_VARARGS, NULL},
	 { (char *)"RelationshipRiskInstrumentOperator_swigregister", RelationshipRiskInstrumentOperator_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_RelatedPartyRole", _wrap_new_RelatedPartyRole, METH_VARARGS, NULL},
	 { (char *)"delete_RelatedPartyRole", _wrap_delete_RelatedPartyRole, METH_VARARGS, NULL},
	 { (char *)"RelatedPartyRole_swigregister", RelatedPartyRole_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_RelationshipRiskSecurityAltID", _wrap_new_RelationshipRiskSecurityAltID, METH_VARARGS, NULL},
	 { (char *)"delete_RelationshipRiskSecurityAltID", _wrap_delete_RelationshipRiskSecurityAltID, METH_VARARGS, NULL},
	 { (char *)"RelationshipRiskSecurityAltID_swigregister", RelationshipRiskSecurityAltID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RelatedPartyAltID", _wrap_new_RelatedPartyAltID, METH_VARARGS, NULL},
	 { (char *)"delete_RelatedPartyAltID", _wrap_delete_RelatedPartyAltID, METH_VARARGS, NULL},
	 { (char *)"RelatedPartyAltID_swigregister", RelatedPartyAltID_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_RelatedContextPartySubID", _wrap_new_RelatedContextPartySubID, METH_VARARGS, NULL},
	 { (char *)"delete_RelatedContextPartySubID", _wrap_delete_RelatedContextPartySubID, METH_VARARGS, NULL},
	 { (char *)"RelatedContextPartySubID_swigregister", RelatedContextPartySubID_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_RelationshipRiskLimitType", _wrap_new_RelationshipRiskLimitType, METH_VARARGS, NULL},
	 { (char *)"delete_RelationshipRiskLimitType", _wrap_delete_RelationshipRiskLimitType, METH_VARARGS, NULL},
	 { (char *)"RelationshipRiskLimitType_swigregister", RelationshipRiskLimitType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RiskSecurityIDSource", _wrap_new_RiskSecurityIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_RiskSecurityIDSource", _wrap_delete_RiskSecurityIDSource, METH_VARARGS, NULL},
	 { (char *)"RiskSecurityIDSource_swigregister", RiskSecurityIDSource_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_RelationshipRiskCouponRate", _wrap_new_RelationshipRiskCouponRate, METH_VARARGS, NULL},
	 { (char *)"delete_RelationshipRiskCouponRate", _wrap_delete_RelationshipRiskCouponRate, METH_VARARGS, NULL},
	 { (char *)"RelationshipRiskCouponRate_swigregister", RelationshipRiskCouponRate_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_RelatedPartyAltSubIDType", _wrap_new_RelatedPartyAltSubIDType, METH_VARARGS, NULL},
	 { (char *)"delete_RelatedPartyAltSubIDType", _wrap_delete_RelatedPartyAltSubIDType, METH_VARARGS, NULL},
	 { (char *)"RelatedPartyAltSubIDType_swigregister", RelatedPartyAltSubIDType_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_RelationshipRiskEncodedSecurityDescLen", _wrap_new_RelationshipRiskEncodedSecurityDescLen, METH_VARARGS, NULL},
	 { (char *)"delete_RelationshipRiskEncodedSecurityDescLen", _wrap_delete_RelationshipRiskEncodedSecurityDescLen, METH_VARARGS, NULL},
	 { (char *)"RelationshipRiskEncodedSecurityDescLen_swigregister", RelationshipRiskEncodedSecurityDescLen_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_RiskLimitPlatform", _wrap_new_RiskLimitPlatform, METH_VARARGS, NULL},
	 { (char *)"delete_RiskLimitPlatform", _wrap_delete_RiskLimitPlatform, METH_VARARGS, NULL},
	 { (char *)"RiskLimitPlatform_swigregister", RiskLimitPlatform_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_RelatedContextPartyRole", _wrap_new_RelatedContextPartyRole, METH_VARARGS, NULL},
	 { (char *)"delete_RelatedContextPartyRole", _wrap_delete_RelatedContextPartyRole, METH_VARARGS, NULL},
	 { (char *)"RelatedContextPartyRole_swigregister", RelatedContextPartyRole_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_RelationshipRiskFlexibleIndicator", _wrap_new_RelationshipRiskFlexibleIndicator, METH_VARARGS, NULL},
	 { (char *)"delete_RelationshipRiskFlexibleIndicator", _wrap_delete_RelationshipRiskFlexibleIndicator, METH_VARARGS, NULL},
	 { (char *)"RelationshipRiskFlexibleIndicator_swigregister", RelationshipRiskFlexibleIndicator_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_RelationshipRiskProductComplex", _wrap_new_RelationshipRiskProductComplex, METH_VARARGS, NULL},
	 { (char *)"delete_RelationshipRiskProductComplex", _wrap_delete_RelationshipRiskProductComplex, METH_VARARGS, NULL},
	 { (char *)"RelationshipRiskProductComplex_swigregister", RelationshipRiskProductComplex_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_RelationshipRiskLimitPlatform", _wrap_new_RelationshipRiskLimitPlatform, METH_VARARGS, NULL},
	 { (char *)"delete_RelationshipRiskLimitPlatform", _wrap_delete_RelationshipRiskLimitPlatform, METH_VARARGS, NULL},
	 { (char *)"RelationshipRiskLimitPlatform_swigregister", RelationshipRiskLimitPlatform_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RelatedPartySubID", _wrap_new_RelatedPartySubID, METH_VARARGS, NULL},
	 { (char *)"delete_RelatedPartySubID", _wrap_delete_RelatedPartySubID, METH_VARARGS, NULL},
	 { (char *)"RelatedPartySubID_swigregister", RelatedPartySubID_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_PartyAltSubID", _wrap_new_PartyAltSubID, METH_VARARGS, NULL},
	 { (char *)"delete_PartyAltSubID", _wrap_delete_PartyAltSubID, METH_VARARGS, NULL},
	 { (char *)"PartyAltSubID_swigregister", PartyAltSubID_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_RiskRestructuringType", _wrap_new_RiskRestructuringType, METH_VARARGS, NULL},
	 { (char *)"delete_RiskRestructuringType", _wrap_delete_RiskRestructuringType, METH_VARARGS, NULL},
	 { (char *)"RiskRestructuringType_swigregister", RiskRestructuringType_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_NoPartyAltSubIDs", _wrap_new_NoPartyAltSubIDs, METH_VARARGS, NULL},
	 { (char *)"delete_NoPartyAltSubIDs", _wrap_delete_NoPartyAltSubIDs, METH_VARARGS, NULL},
	 { (char *)"NoPartyAltSubIDs_swigregister", NoPartyAltSubIDs_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_RelatedContextPartyID", _wrap_new_RelatedContextPartyID, METH_VARARGS, NULL},
	 { (char *)"delete_RelatedContextPartyID", _wrap_delete_RelatedContextPartyID, METH_VARARGS, NULL},
	 { (char *)"RelatedContextPartyID_swigregister", RelatedContextPartyID_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_RelationshipRiskSecurityExchange", _wrap_new_RelationshipRiskSecurityExchange, METH_VARARGS, NULL},
	 { (char *)"delete_RelationshipRiskSecurityExchange", _wrap_delete_RelationshipRiskSecurityExchange, METH_VARARGS, NULL},
	 { (char *)"RelationshipRiskSecurityExchange_swigregister", RelationshipRiskSecurityExchange_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_AsgnReqID", _wrap_new_AsgnReqID, METH_VARARGS, NULL},
	 { (char *)"delete_AsgnReqID", _wrap_delete_AsgnReqID, METH_VARARGS, NULL},
	 { (char *)"AsgnReqID_swigregister", AsgnReqID_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_RiskCFICode", _wrap_new_RiskCFICode, METH_VARARGS, NULL},
	 { (char *)"delete_RiskCFICode", _wrap_delete_RiskCFICode, METH_VARARGS, NULL},
	 { (char *)"RiskCFICode_swigregister", RiskCFICode_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_RelationshipRiskSecurityDesc", _wrap_new_RelationshipRiskSecurityDesc, METH_VARARGS, NULL},
	 { (char *)"delete_RelationshipRiskSecurityDesc", _wrap_delete_RelationshipRiskSecurityDesc, METH_VARARGS, NULL},
	 { (char *)"RelationshipRiskSecurityDesc_swigregister", RelationshipRiskSecurityDesc_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_PartyAltSubIDType", _wrap_new_PartyAltSubIDType, METH_VARARGS, NULL},
	 { (char *)"delete_PartyAltSubIDType", _wrap_delete_PartyAltSubIDType, METH_VARARGS, NULL},
	 { (char *)"PartyAltSubIDType_swigregister", PartyAltSubIDType_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_ContextPartySubID", _wrap_new_ContextPartySubID, METH_VARARGS, NULL},
	 { (char *)"delete_ContextPartySubID", _wrap_delete_ContextPartySubID, METH_VARARGS, NULL},
	 { (char *)"ContextPartySubID_swigregister", ContextPartySubID_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_NoRelatedPartyAltIDs", _wrap_new_NoRelatedPartyAltIDs, METH_VARARGS, NULL},
	 { (char *)"delete_NoRelatedPartyAltIDs", _wrap_delete_NoRelatedPartyAltIDs, METH_VARARGS, NULL},
	 { (char *)"NoRelatedPartyAltIDs_swigregister", NoRelatedPartyAltIDs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RiskProductComplex", _wrap_new_RiskProductComplex, METH_VARARGS, NULL},
	 { (char *)"delete_RiskProductComplex", _wrap_delete_RiskProductComplex, METH_VARARGS, NULL},
	 { (char *)"RiskProductComplex_swigregister", RiskProductComplex_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_RelatedPartySubIDType", _wrap_new_RelatedPartySubIDType, METH_VARARGS, NULL},
	 { (char *)"delete_RelatedPartySubIDType", _wrap_delete_RelatedPartySubIDType, METH_VARARGS, NULL},
	 { (char *)"RelatedPartySubIDType_swigregister", RelatedPartySubIDType_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_RelatedPartyIDSource", _wrap_new_RelatedPartyIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_RelatedPartyIDSource", _wrap_delete_RelatedPartyIDSource, METH_VARARGS, NULL},
	 { (char *)"RelatedPartyIDSource_swigregister", RelatedPartyIDSource_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_PartyDetailsRequestResult", _wrap_new_PartyDetailsRequestResult, METH_VARARGS, NULL},
	 { (char *)"delete_PartyDetailsRequestResult", _wrap_delete_PartyDetailsRequestResult, METH_VARARGS, NULL},
	 { (char *)"PartyDetailsRequestResult_swigregister", PartyDetailsRequestResult_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_RiskLimitAmount", _wrap_new_RiskLimitAmount, METH_VARARGS, NULL},
	 { (char *)"delete_RiskLimitAmount", _wrap_delete_RiskLimitAmount, METH_VARARGS, NULL},
	 { (char *)"RiskLimitAmount_swigregister", RiskLimitAmount_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_RelationshipRiskCFICode", _wrap_new_RelationshipRiskCFICode, METH_VARARGS, NULL},
	 { (char *)"delete_RelationshipRiskCFICode", _wrap_delete_RelationshipRiskCFICode, METH_VARARGS, NULL},
	 { (char *)"RelationshipRiskCFICode_swigregister", RelationshipRiskCFICode_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoRelatedPartySubIDs", _wrap_new_NoRelatedPartySubIDs, METH_VARARGS, NULL},
	 { (char *)"delete_NoRelatedPartySubIDs", _wrap_delete_NoRelatedPartySubIDs, METH_VARARGS, NULL},
	 { (char *)"NoRelatedPartySubIDs_swigregister", NoRelatedPartySubIDs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RiskSymbolSfx", _wrap_new_RiskSymbolSfx, METH_VARARGS, NULL},
	 { (char *)"delete_RiskSymbolSfx", _wrap_delete_RiskSymbolSfx, METH_VARARGS, NULL},
	 { (char *)"RiskSymbolSfx_swigregister", RiskSymbolSfx_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_NoContextPartySubIDs", _wrap_new_NoContextPartySubIDs, METH_VARARGS, NULL},
	 { (char *)"delete_NoContextPartySubIDs", _wrap_delete_NoContextPartySubIDs, METH_VARARGS, NULL},
	 { (char *)"NoContextPartySubIDs_swigregister", NoContextPartySubIDs_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_RiskInstrumentMultiplier", _wrap_new_RiskInstrumentMultiplier, METH_VARARGS, NULL},
	 { (char *)"delete_RiskInstrumentMultiplier", _wrap_delete_RiskInstrumentMultiplier, METH_VARARGS, NULL},
	 { (char *)"RiskInstrumentMultiplier_swigregister", RiskInstrumentMultiplier_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_NoPartyListResponseTypes", _wrap_new_NoPartyListResponseTypes, METH_VARARGS, NULL},
	 { (char *)"delete_NoPartyListResponseTypes", _wrap_delete_NoPartyListResponseTypes, METH_VARARGS, NULL},
	 { (char *)"NoPartyListResponseTypes_swigregister", NoPartyListResponseTypes_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_NoContextPartyIDs", _wrap_new_NoContextPartyIDs, METH_VARARGS, NULL},
	 { (char *)"delete_NoContextPartyIDs", _wrap_delete_NoContextPartyIDs, METH_VARARGS, NULL},
	 { (char *)"NoContextPartyIDs_swigregister", NoContextPartyIDs_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_RiskSecurityExchange", _wrap_new_RiskSecurityExchange, METH_VARARGS, NULL},
	 { (char *)"delete_RiskSecurityExchange", _wrap_delete_RiskSecurityExchange, METH_VARARGS, NULL},
	 { (char *)"RiskSecurityExchange_swigregister", RiskSecurityExchange_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_EncodedSymbol", _wrap_new_EncodedSymbol, METH_VARARGS, NULL},
	 { (char *)"delete_EncodedSymbol", _wrap_delete_EncodedSymbol, METH_VARARGS, NULL},
	 { (char *)"EncodedSymbol_swigregister", EncodedSymbol_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_SecDefStatus", _wrap_new_SecDefStatus, METH_VARARGS, NULL},
	 { (char *)"delete_SecDefStatus", _wrap_delete_SecDefStatus, METH_VARARGS, NULL},
	 { (char *)"SecDefStatus_swigregister", SecDefStatus_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_RelatedContextPartyIDSource", _wrap_new_RelatedContextPartyIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_RelatedContextPartyIDSource", _wrap_delete_RelatedContextPartyIDSource, METH_VARARGS, NULL},
	 { (char *)"RelatedContextPartyIDSource_swigregister", RelatedContextPartyIDSource_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_NoPartyList", _wrap_new_NoPartyList, METH_VARARGS, NULL},
	 { (char *)"delete_NoPartyList", _wrap_delete_NoPartyList, METH_VARARGS, NULL},
	 { (char *)"NoPartyList_swigregister", NoPartyList_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_RiskCouponRate", _wrap_new_RiskCouponRate, METH_VARARGS, NULL},
	 { (char *)"delete_RiskCouponRate", _wrap_delete_RiskCouponRate, METH_VARARGS, NULL},
	 { (char *)"RiskCouponRate_swigregister", RiskCouponRate_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_NoRiskLimits", _wrap_new_NoRiskLimits, METH_VARARGS, NULL},
	 { (char *)"delete_NoRiskLimits", _wrap_delete_NoRiskLimits, METH_VARARGS, NULL},
	 { (char *)"NoRiskLimits_swigregister", NoRiskLimits_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_RelationshipRiskSecurityIDSource", _wrap_new_RelationshipRiskSecurityIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_RelationshipRiskSecurityIDSource", _wrap_delete_RelationshipRiskSecurityIDSource, METH_VARARGS, NULL},
	 { (char *)"RelationshipRiskSecurityIDSource_swigregister", RelationshipRiskSecurityIDSource_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_NoRelatedPartyAltSubIDs", _wrap_new_NoRelatedPartyAltSubIDs, METH_VARARGS, NULL},
	 { (char *)"delete_NoRelatedPartyAltSubIDs", _wrap_delete_NoRelatedPartyAltSubIDs, METH_VARARGS, NULL},
	 { (char *)"NoRelatedPartyAltSubIDs_swigregister", NoRelatedPartyAltSubIDs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RiskProduct", _wrap_new_RiskProduct, METH_VARARGS, NULL},
	 { (char *)"delete_RiskProduct", _wrap_delete_RiskProduct, METH_VARARGS, NULL},
	 { (char *)"RiskProduct_swigregister", RiskProduct_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RiskSecurityAltIDSource", _wrap_new_RiskSecurityAltIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_RiskSecurityAltIDSource", _wrap_delete_RiskSecurityAltIDSource, METH_VARARGS, NULL},
	 { (char *)"RiskSecurityAltIDSource_swigregister", RiskSecurityAltIDSource_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_RiskPutOrCall", _wrap_new_RiskPutOrCall, METH_VARARGS, NULL},
	 { (char *)"delete_RiskPutOrCall", _wrap_delete_RiskPutOrCall, METH_VARARGS, NULL},
	 { (char *)"RiskPutOrCall_swigregister", RiskPutOrCall_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RiskSecurityGroup", _wrap_new_RiskSecurityGroup, METH_VARARGS, NULL},
	 { (char *)"delete_RiskSecurityGroup", _wrap_delete_RiskSecurityGroup, METH_VARARGS, NULL},
	 { (char *)"RiskSecurityGroup_swigregister", RiskSecurityGroup_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_RiskSymbol", _wrap_new_RiskSymbol, METH_VARARGS, NULL},
	 { (char *)"delete_RiskSymbol", _wrap_delete_RiskSymbol, METH_VARARGS, NULL},
	 { (char *)"RiskSymbol_swigregister", RiskSymbol_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_RiskSecurityType", _wrap_new_RiskSecurityType, METH_VARARGS, NULL},
	 { (char *)"delete_RiskSecurityType", _wrap_delete_RiskSecurityType, METH_VARARGS, NULL},
	 { (char *)"RiskSecurityType_swigregister", RiskSecurityType_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_RiskSeniority", _wrap_new_RiskSeniority, METH_VARARGS, NULL},
	 { (char *)"delete_RiskSeniority", _wrap_delete_RiskSeniority, METH_VARARGS, NULL},
	 { (char *)"RiskSeniority_swigregister", RiskSeniority_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_RiskFlexibleIndicator", _wrap_new_RiskFlexibleIndicator, METH_VARARGS, NULL},
	 { (char *)"delete_RiskFlexibleIndicator", _wrap_delete_RiskFlexibleIndicator, METH_VARARGS, NULL},
	 { (char *)"RiskFlexibleIndicator_swigregister", RiskFlexibleIndicator_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_RelationshipRiskSecurityGroup", _wrap_new_RelationshipRiskSecurityGroup, METH_VARARGS, NULL},
	 { (char *)"delete_RelationshipRiskSecurityGroup", _wrap_delete_RelationshipRiskSecurityGroup, METH_VARARGS, NULL},
	 { (char *)"RelationshipRiskSecurityGroup_swigregister", RelationshipRiskSecurityGroup_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_DerivativeSecurityListRequestType", _wrap_new_DerivativeSecurityListRequestType, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeSecurityListRequestType", _wrap_delete_DerivativeSecurityListRequestType, METH_VARARGS, NULL},
	 { (char *)"DerivativeSecurityListRequestType_swigregister", DerivativeSecurityListRequestType_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_ContextPartyID", _wrap_new_ContextPartyID, METH_VARARGS, NULL},
	 { (char *)"delete_ContextPartyID", _wrap_delete_ContextPartyID, METH_VARARGS, NULL},
	 { (char *)"ContextPartyID_swigregister", ContextPartyID_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_RelationshipRiskInstrumentSettlType", _wrap_new_RelationshipRiskInstrumentSettlType, METH_VARARGS, NULL},
	 { (char *)"delete_RelationshipRiskInstrumentSettlType", _wrap_delete_RelationshipRiskInstrumentSettlType, METH_VARARGS, NULL},
	 { (char *)"RelationshipRiskInstrumentSettlType_swigregister", RelationshipRiskInstrumentSettlType_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_NoRelationshipRiskInstruments", _wrap_new_NoRelationshipRiskInstruments, METH_VARARGS, NULL},
	 { (char *)"delete_NoRelationshipRiskInstruments", _wrap_delete_NoRelationshipRiskInstruments, METH_VARARGS, NULL},
	 { (char *)"NoRelationshipRiskInstruments_swigregister", NoRelationshipRiskInstruments_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_PartyDetailsListReportID", _wrap_new_PartyDetailsListReportID, METH_VARARGS, NULL},
	 { (char *)"delete_PartyDetailsListReportID", _wrap_delete_PartyDetailsListReportID, METH_VARARGS, NULL},
	 { (char *)"PartyDetailsListReportID_swigregister", PartyDetailsListReportID_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_NoRelationshipRiskWarningLevels", _wrap_new_NoRelationshipRiskWarningLevels, METH_VARARGS, NULL},
	 { (char *)"delete_NoRelationshipRiskWarningLevels", _wrap_delete_NoRelationshipRiskWarningLevels, METH_VARARGS, NULL},
	 { (char *)"NoRelationshipRiskWarningLevels_swigregister", NoRelationshipRiskWarningLevels_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RelationshipRiskProduct", _wrap_new_RelationshipRiskProduct, METH_VARARGS, NULL},
	 { (char *)"delete_RelationshipRiskProduct", _wrap_delete_RelationshipRiskProduct, METH_VARARGS, NULL},
	 { (char *)"RelationshipRiskProduct_swigregister", RelationshipRiskProduct_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_PartyAltID", _wrap_new_PartyAltID, METH_VARARGS, NULL},
	 { (char *)"delete_PartyAltID", _wrap_delete_PartyAltID, METH_VARARGS, NULL},
	 { (char *)"PartyAltID_swigregister", PartyAltID_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_ContextPartyIDSource", _wrap_new_ContextPartyIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_ContextPartyIDSource", _wrap_delete_ContextPartyIDSource, METH_VARARGS, NULL},
	 { (char *)"ContextPartyIDSource_swigregister", ContextPartyIDSource_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_NoRelatedContextPartySubIDs", _wrap_new_NoRelatedContextPartySubIDs, METH_VARARGS, NULL},
	 { (char *)"delete_NoRelatedContextPartySubIDs", _wrap_delete_NoRelatedContextPartySubIDs, METH_VARARGS, NULL},
	 { (char *)"NoRelatedContextPartySubIDs_swigregister", NoRelatedContextPartySubIDs_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_RiskLimitType", _wrap_new_RiskLimitType, METH_VARARGS, NULL},
	 { (char *)"delete_RiskLimitType", _wrap_delete_RiskLimitType, METH_VARARGS, NULL},
	 { (char *)"RiskLimitType_swigregister", RiskLimitType_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_RequestedPartyRole", _wrap_new_RequestedPartyRole, METH_VARARGS, NULL},
	 { (char *)"delete_RequestedPartyRole", _wrap_delete_RequestedPartyRole, METH_VARARGS, NULL},
	 { (char *)"RequestedPartyRole_swigregister", RequestedPartyRole_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_RelationshipRiskSeniority", _wrap_new_RelationshipRiskSeniority, METH_VARARGS, NULL},
	 { (char *)"delete_RelationshipRiskSeniority", _wrap_delete_RelationshipRiskSeniority, METH_VARARGS, NULL},
	 { (char *)"RelationshipRiskSeniority_swigregister", RelationshipRiskSeniority_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_NoPartyRelationships", _wrap_new_NoPartyRelationships, METH_VARARGS, NULL},
	 { (char *)"delete_NoPartyRelationships", _wrap_delete_NoPartyRelationships, METH_VARARGS, NULL},
	 { (char *)"NoPartyRelationships_swigregister", NoPartyRelationships_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_NoRiskWarningLevels", _wrap_new_NoRiskWarningLevels, METH_VARARGS, NULL},
	 { (char *)"delete_NoRiskWarningLevels", _wrap_delete_NoRiskWarningLevels, METH_VARARGS, NULL},
	 { (char *)"NoRiskWarningLevels_swigregister", NoRiskWarningLevels_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_RelationshipRiskLimitAmount", _wrap_new_RelationshipRiskLimitAmount, METH_VARARGS, NULL},
	 { (char *)"delete_RelationshipRiskLimitAmount", _wrap_delete_RelationshipRiskLimitAmount, METH_VARARGS, NULL},
	 { (char *)"RelationshipRiskLimitAmount_swigregister", RelationshipRiskLimitAmount_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_RiskSecurityID", _wrap_new_RiskSecurityID, METH_VARARGS, NULL},
	 { (char *)"delete_RiskSecurityID", _wrap_delete_RiskSecurityID, METH_VARARGS, NULL},
	 { (char *)"RiskSecurityID_swigregister", RiskSecurityID_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_RiskMaturityTime", _wrap_new_RiskMaturityTime, METH_VARARGS, NULL},
	 { (char *)"delete_RiskMaturityTime", _wrap_delete_RiskMaturityTime, METH_VARARGS, NULL},
	 { (char *)"RiskMaturityTime_swigregister", RiskMaturityTime_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_RiskInstrumentOperator", _wrap_new_RiskInstrumentOperator, METH_VARARGS, NULL},
	 { (char *)"delete_RiskInstrumentOperator", _wrap_delete_RiskInstrumentOperator, METH_VARARGS, NULL},
	 { (char *)"RiskInstrumentOperator_swigregister", RiskInstrumentOperator_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_RelationshipRiskSecurityAltIDSource", _wrap_new_RelationshipRiskSecurityAltIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_RelationshipRiskSecurityAltIDSource", _wrap_delete_RelationshipRiskSecurityAltIDSource, METH_VARARGS, NULL},
	 { (char *)"RelationshipRiskSecurityAltIDSource_swigregister", RelationshipRiskSecurityAltIDSource_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_ContextPartyRole", _wrap_new_ContextPartyRole, METH_VARARGS, NULL},
	 { (char *)"delete_ContextPartyRole", _wrap_delete_ContextPartyRole, METH_VARARGS, NULL},
	 { (char *)"ContextPartyRole_swigregister", ContextPartyRole_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_RelationshipRiskEncodedSecurityDesc", _wrap_new_RelationshipRiskEncodedSecurityDesc, METH_VARARGS, NULL},
	 { (char *)"delete_RelationshipRiskEncodedSecurityDesc", _wrap_delete_RelationshipRiskEncodedSecurityDesc, METH_VARARGS, NULL},
	 { (char *)"RelationshipRiskEncodedSecurityDesc_swigregister", RelationshipRiskEncodedSecurityDesc_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RelationshipRiskRestructuringType", _wrap_new_RelationshipRiskRestructuringType, METH_VARARGS, NULL},
	 { (char *)"delete_RelationshipRiskRestructuringType", _wrap_delete_RelationshipRiskRestructuringType, METH_VARARGS, NULL},
	 { (char *)"RelationshipRiskRestructuringType_swigregister", RelationshipRiskRestructuringType_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_RiskSecuritySubType", _wrap_new_RiskSecuritySubType, METH_VARARGS, NULL},
	 { (char *)"delete_RiskSecuritySubType", _wrap_delete_RiskSecuritySubType, METH_VARARGS, NULL},
	 { (char *)"RiskSecuritySubType_swigregister", RiskSecuritySubType_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_NoPartyAltIDs", _wrap_new_NoPartyAltIDs, METH_VARARGS, NULL},
	 { (char *)"delete_NoPartyAltIDs", _wrap_delete_NoPartyAltIDs, METH_VARARGS, NULL},
	 { (char *)"NoPartyAltIDs_swigregister", NoPartyAltIDs_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_NoRequestedPartyRoles", _wrap_new_NoRequestedPartyRoles, METH_VARARGS, NULL},
	 { (char *)"delete_NoRequestedPartyRoles", _wrap_delete_NoRequestedPartyRoles, METH_VARARGS, NULL},
	 { (char *)"NoRequestedPartyRoles_swigregister", NoRequestedPartyRoles_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_RelationshipRiskInstrumentMultiplier", _wrap_new_RelationshipRiskInstrumentMultiplier, METH_VARARGS, NULL},
	 { (char *)"delete_RelationshipRiskInstrumentMultiplier", _wrap_delete_RelationshipRiskInstrumentMultiplier, METH_VARARGS, NULL},
	 { (char *)"RelationshipRiskInstrumentMultiplier_swigregister", RelationshipRiskInstrumentMultiplier_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoRiskInstruments", _wrap_new_NoRiskInstruments, METH_VARARGS, NULL},
	 { (char *)"delete_NoRiskInstruments", _wrap_delete_NoRiskInstruments, METH_VARARGS, NULL},
	 { (char *)"NoRiskInstruments_swigregister", NoRiskInstruments_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_RiskInstrumentSettlType", _wrap_new_RiskInstrumentSettlType, METH_VARARGS, NULL},
	 { (char *)"delete_RiskInstrumentSettlType", _wrap_delete_RiskInstrumentSettlType, METH_VARARGS, NULL},
	 { (char *)"RiskInstrumentSettlType_swigregister", RiskInstrumentSettlType_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_RelationshipRiskSecurityID", _wrap_new_RelationshipRiskSecurityID, METH_VARARGS, NULL},
	 { (char *)"delete_RelationshipRiskSecurityID", _wrap_delete_RelationshipRiskSecurityID, METH_VARARGS, NULL},
	 { (char *)"RelationshipRiskSecurityID_swigregister", RelationshipRiskSecurityID_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_RiskLimitCurrency", _wrap_new_RiskLimitCurrency, METH_VARARGS, NULL},
	 { (char *)"delete_RiskLimitCurrency", _wrap_delete_RiskLimitCurrency, METH_VARARGS, NULL},
	 { (char *)"RiskLimitCurrency_swigregister", RiskLimitCurrency_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PartyDetailsListRequestID", _wrap_new_PartyDetailsListRequestID, METH_VARARGS, NULL},
	 { (char *)"delete_PartyDetailsListRequestID", _wrap_delete_PartyDetailsListRequestID, METH_VARARGS, NULL},
	 { (char *)"PartyDetailsListRequestID_swigregister", PartyDetailsListRequestID_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_RelationshipRiskSecurityType", _wrap_new_RelationshipRiskSecurityType, METH_VARARGS, NULL},
	 { (char *)"delete_RelationshipRiskSecurityType", _wrap_delete_RelationshipRiskSecurityType, METH_VARARGS, NULL},
	 { (char *)"RelationshipRiskSecurityType_swigregister", RelationshipRiskSecurityType_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_RelatedPartyAltSubID", _wrap_new_RelatedPartyAltSubID, METH_VARARGS, NULL},
	 { (char *)"delete_RelatedPartyAltSubID", _wrap_delete_RelatedPartyAltSubID, METH_VARARGS, NULL},
	 { (char *)"RelatedPartyAltSubID_swigregister", RelatedPartyAltSubID_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_NoRelationshipRiskSecurityAltID", _wrap_new_NoRelationshipRiskSecurityAltID, METH_VARARGS, NULL},
	 { (char *)"delete_NoRelationshipRiskSecurityAltID", _wrap_delete_NoRelationshipRiskSecurityAltID, METH_VARARGS, NULL},
	 { (char *)"NoRelationshipRiskSecurityAltID_swigregister", NoRelationshipRiskSecurityAltID_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_RelationshipRiskLimitCurrency", _wrap_new_RelationshipRiskLimitCurrency, METH_VARARGS, NULL},
	 { (char *)"delete_RelationshipRiskLimitCurrency", _wrap_delete_RelationshipRiskLimitCurrency, METH_VARARGS, NULL},
	 { (char *)"RelationshipRiskLimitCurrency_swigregister", RelationshipRiskLimitCurrency_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_RelationshipRiskWarningLevelName", _wrap_new_RelationshipRiskWarningLevelName, METH_VARARGS, NULL},
	 { (char *)"delete_RelationshipRiskWarningLevelName", _wrap_delete_RelationshipRiskWarningLevelName, METH_VARARGS, NULL},
	 { (char *)"RelationshipRiskWarningLevelName_swigregister", RelationshipRiskWarningLevelName_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_TotNoPartyList", _wrap_new_TotNoPartyList, METH_VARARGS, NULL},
	 { (char *)"delete_TotNoPartyList", _wrap_delete_TotNoPartyList, METH_VARARGS, NULL},
	 { (char *)"TotNoPartyList_swigregister", TotNoPartyList_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PartyListResponseType", _wrap_new_PartyListResponseType, METH_VARARGS, NULL},
	 { (char *)"delete_PartyListResponseType", _wrap_delete_PartyListResponseType, METH_VARARGS, NULL},
	 { (char *)"PartyListResponseType_swigregister", PartyListResponseType_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_ContextPartySubIDType", _wrap_new_ContextPartySubIDType, METH_VARARGS, NULL},
	 { (char *)"delete_ContextPartySubIDType", _wrap_delete_ContextPartySubIDType, METH_VARARGS, NULL},
	 { (char *)"ContextPartySubIDType_swigregister", ContextPartySubIDType_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_RelationshipRiskMaturityMonthYear", _wrap_new_RelationshipRiskMaturityMonthYear, METH_VARARGS, NULL},
	 { (char *)"delete_RelationshipRiskMaturityMonthYear", _wrap_delete_RelationshipRiskMaturityMonthYear, METH_VARARGS, NULL},
	 { (char *)"RelationshipRiskMaturityMonthYear_swigregister", RelationshipRiskMaturityMonthYear_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RelatedPartyAltIDSource", _wrap_new_RelatedPartyAltIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_RelatedPartyAltIDSource", _wrap_delete_RelatedPartyAltIDSource, METH_VARARGS, NULL},
	 { (char *)"RelatedPartyAltIDSource_swigregister", RelatedPartyAltIDSource_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_PartyRelationship", _wrap_new_PartyRelationship, METH_VARARGS, NULL},
	 { (char *)"delete_PartyRelationship", _wrap_delete_PartyRelationship, METH_VARARGS, NULL},
	 { (char *)"PartyRelationship_swigregister", PartyRelationship_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_RiskMaturityMonthYear", _wrap_new_RiskMaturityMonthYear, METH_VARARGS, NULL},
	 { (char *)"delete_RiskMaturityMonthYear", _wrap_delete_RiskMaturityMonthYear, METH_VARARGS, NULL},
	 { (char *)"RiskMaturityMonthYear_swigregister", RiskMaturityMonthYear_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_RiskEncodedSecurityDescLen", _wrap_new_RiskEncodedSecurityDescLen, METH_VARARGS, NULL},
	 { (char *)"delete_RiskEncodedSecurityDescLen", _wrap_delete_RiskEncodedSecurityDescLen, METH_VARARGS, NULL},
	 { (char *)"RiskEncodedSecurityDescLen_swigregister", RiskEncodedSecurityDescLen_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RelationshipRiskSymbol", _wrap_new_RelationshipRiskSymbol, METH_VARARGS, NULL},
	 { (char *)"delete_RelationshipRiskSymbol", _wrap_delete_RelationshipRiskSymbol, METH_VARARGS, NULL},
	 { (char *)"RelationshipRiskSymbol_swigregister", RelationshipRiskSymbol_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoRelatedContextPartyIDs", _wrap_new_NoRelatedContextPartyIDs, METH_VARARGS, NULL},
	 { (char *)"delete_NoRelatedContextPartyIDs", _wrap_delete_NoRelatedContextPartyIDs, METH_VARARGS, NULL},
	 { (char *)"NoRelatedContextPartyIDs_swigregister", NoRelatedContextPartyIDs_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_RelatedContextPartySubIDType", _wrap_new_RelatedContextPartySubIDType, METH_VARARGS, NULL},
	 { (char *)"delete_RelatedContextPartySubIDType", _wrap_delete_RelatedContextPartySubIDType, METH_VARARGS, NULL},
	 { (char *)"RelatedContextPartySubIDType_swigregister", RelatedContextPartySubIDType_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_RelationshipRiskWarningLevelPercent", _wrap_new_RelationshipRiskWarningLevelPercent, METH_VARARGS, NULL},
	 { (char *)"delete_RelationshipRiskWarningLevelPercent", _wrap_delete_RelationshipRiskWarningLevelPercent, METH_VARARGS, NULL},
	 { (char *)"RelationshipRiskWarningLevelPercent_swigregister", RelationshipRiskWarningLevelPercent_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_RiskSecurityDesc", _wrap_new_RiskSecurityDesc, METH_VARARGS, NULL},
	 { (char *)"delete_RiskSecurityDesc", _wrap_delete_RiskSecurityDesc, METH_VARARGS, NULL},
	 { (char *)"RiskSecurityDesc_swigregister", RiskSecurityDesc_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_NoRiskSecurityAltID", _wrap_new_NoRiskSecurityAltID, METH_VARARGS, NULL},
	 { (char *)"delete_NoRiskSecurityAltID", _wrap_delete_NoRiskSecurityAltID, METH_VARARGS, NULL},
	 { (char *)"NoRiskSecurityAltID_swigregister", NoRiskSecurityAltID_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_RiskSecurityAltID", _wrap_new_RiskSecurityAltID, METH_VARARGS, NULL},
	 { (char *)"delete_RiskSecurityAltID", _wrap_delete_RiskSecurityAltID, METH_VARARGS, NULL},
	 { (char *)"RiskSecurityAltID_swigregister", RiskSecurityAltID_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_RelationshipRiskPutOrCall", _wrap_new_RelationshipRiskPutOrCall, METH_VARARGS, NULL},
	 { (char *)"delete_RelationshipRiskPutOrCall", _wrap_delete_RelationshipRiskPutOrCall, METH_VARARGS, NULL},
	 { (char *)"RelationshipRiskPutOrCall_swigregister", RelationshipRiskPutOrCall_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_RelationshipRiskSymbolSfx", _wrap_new_RelationshipRiskSymbolSfx, METH_VARARGS, NULL},
	 { (char *)"delete_RelationshipRiskSymbolSfx", _wrap_delete_RelationshipRiskSymbolSfx, METH_VARARGS, NULL},
	 { (char *)"RelationshipRiskSymbolSfx_swigregister", RelationshipRiskSymbolSfx_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_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) {
    return (void *)((FIX::CheckSumField *)  ((FIX::CheckSum *) x));
}
static void *_p_FIX__NullLogTo_p_FIX__Log(void *x) {
    return (void *)((FIX::Log *)  ((FIX::NullLog *) x));
}
static void *_p_FIX__FileLogTo_p_FIX__Log(void *x) {
    return (void *)((FIX::Log *)  ((FIX::FileLog *) x));
}
static void *_p_FIX__ScreenLogTo_p_FIX__Log(void *x) {
    return (void *)((FIX::Log *)  ((FIX::ScreenLog *) x));
}
static void *_p_IntArrayTo_p_int(void *x) {
    return (void *)((int *)  ((IntArray *) x));
}
static void *_p_FIX__SocketInitiatorTo_p_FIX__Initiator(void *x) {
    return (void *)((FIX::Initiator *)  ((FIX::SocketInitiator *) x));
}
static void *_p_FIX__SocketAcceptorTo_p_FIX__Acceptor(void *x) {
    return (void *)((FIX::Acceptor *)  ((FIX::SocketAcceptor *) x));
}
static void *_p_FIX__MDEntryTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::MDEntryType *) x));
}
static void *_p_FIX__RegistStatusTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::RegistStatus *) x));
}
static void *_p_FIX__OrdStatusTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::OrdStatus *) x));
}
static void *_p_FIX__MatchStatusTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::MatchStatus *) x));
}
static void *_p_FIX__BidTradeTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::BidTradeType *) x));
}
static void *_p_FIX__FundRenewWaivTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::FundRenewWaiv *) x));
}
static void *_p_FIX__TradeTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::TradeType *) x));
}
static void *_p_FIX__OpenCloseTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::OpenClose *) x));
}
static void *_p_FIX__UrgencyTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::Urgency *) x));
}
static void *_p_FIX__IOIOthSvcTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::IOIOthSvc *) x));
}
static void *_p_FIX__EmailTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::EmailType *) x));
}
static void *_p_FIX__AllocTransTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::AllocTransType *) x));
}
static void *_p_FIX__ExecTransTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::ExecTransType *) x));
}
static void *_p_FIX__BidRequestTransTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::BidRequestTransType *) x));
}
static void *_p_FIX__SettlInstTransTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::SettlInstTransType *) x));
}
static void *_p_FIX__RegistTransTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::RegistTransType *) x));
}
static void *_p_FIX__ListExecInstTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::ListExecInstType *) x));
}
static void *_p_FIX__IOITransTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::IOITransType *) x));
}
static void *_p_FIX__DlvyInstTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::DlvyInstType *) x));
}
static void *_p_FIX__SettlObligTransTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::SettlObligTransType *) x));
}
static void *_p_FIX__QuoteQualifierTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::QuoteQualifier *) x));
}
static void *_p_FIX__IOIQualifierTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::IOIQualifier *) x));
}
static void *_p_FIX__SettlInstModeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::SettlInstMode *) x));
}
static void *_p_FIX__ExecTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::ExecType *) x));
}
static void *_p_FIX__DerivativeExerciseStyleTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::DerivativeExerciseStyle *) x));
}
static void *_p_FIX__TimeInForceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::TimeInForce *) x));
}
static void *_p_FIX__TriggerTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::TriggerType *) x));
}
static void *_p_FIX__OwnershipTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::OwnershipType *) x));
}
static void *_p_FIX__AssignmentMethodTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::AssignmentMethod *) x));
}
static void *_p_FIX__SettlMethodTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::SettlMethod *) x));
}
static void *_p_FIX__DerivativeInstrmtAssignmentMethodTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::DerivativeInstrmtAssignmentMethod *) x));
}
static void *_p_FIX__InstrmtAssignmentMethodTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::InstrmtAssignmentMethod *) x));
}
static void *_p_FIX__DerivativeSettlMethodTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::DerivativeSettlMethod *) x));
}
static void *_p_FIX__MDReqRejReasonTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::MDReqRejReason *) x));
}
static void *_p_FIX__BookingUnitTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::BookingUnit *) x));
}
static void *_p_FIX__SettlCurrFxRateCalcTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::SettlCurrFxRateCalc *) x));
}
static void *_p_FIX__UnderlyingFXRateCalcTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::UnderlyingFXRateCalc *) x));
}
static void *_p_FIX__TriggerActionTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::TriggerAction *) x));
}
static void *_p_FIX__DiscretionInstTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::DiscretionInst *) x));
}
static void *_p_FIX__ExecInstValueTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::ExecInstValue *) x));
}
static void *_p_FIX__TriggerPriceTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::TriggerPriceType *) x));
}
static void *_p_FIX__ExecPriceTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::ExecPriceType *) x));
}
static void *_p_FIX__SettlObligSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::SettlObligSource *) x));
}
static void *_p_FIX__MassCancelRequestTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::MassCancelRequestType *) x));
}
static void *_p_FIX__SubscriptionRequestTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::SubscriptionRequestType *) x));
}
static void *_p_FIX__TriggerPriceTypeScopeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::TriggerPriceTypeScope *) x));
}
static void *_p_FIX__ProcessCodeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::ProcessCode *) x));
}
static void *_p_FIX__LotTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::LotType *) x));
}
static void *_p_FIX__LegSideTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::LegSide *) x));
}
static void *_p_FIX__TriggerPriceDirectionTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::TriggerPriceDirection *) x));
}
static void *_p_FIX__TickDirectionTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::TickDirection *) x));
}
static void *_p_FIX__RoundingDirectionTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::RoundingDirection *) x));
}
static void *_p_FIX__MsgDirectionTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::MsgDirection *) x));
}
static void *_p_FIX__HaltReasonCharTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::HaltReasonChar *) x));
}
static void *_p_FIX__OrderCapacityTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::OrderCapacity *) x));
}
static void *_p_FIX__DealingCapacityTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::DealingCapacity *) x));
}
static void *_p_FIX__LastCapacityTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::LastCapacity *) x));
}
static void *_p_FIX__PriceProtectionScopeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::PriceProtectionScope *) x));
}
static void *_p_FIX__BasisPxTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::BasisPxType *) x));
}
static void *_p_FIX__PositionEffectTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::PositionEffect *) x));
}
static void *_p_FIX__LegPositionEffectTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::LegPositionEffect *) x));
}
static void *_p_FIX__AllocPositionEffectTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::AllocPositionEffect *) x));
}
static void *_p_FIX__VenueTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::VenueType *) x));
}
static void *_p_FIX__HandlInstTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::HandlInst *) x));
}
static void *_p_FIX__MoneyLaunderingStatusTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::MoneyLaunderingStatus *) x));
}
static void *_p_FIX__ExecAckStatusTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::ExecAckStatus *) x));
}
static void *_p_FIX__CxlRejResponseToTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::CxlRejResponseTo *) x));
}
static void *_p_FIX__DisplayWhenTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::DisplayWhen *) x));
}
static void *_p_FIX__OrderCategoryTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::OrderCategory *) x));
}
static void *_p_FIX__MultiLegReportingTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::MultiLegReportingType *) x));
}
static void *_p_FIX__CxlTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::CxlType *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartyIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::UnderlyingInstrumentPartyIDSource *) x));
}
static void *_p_FIX__RelatedContextPartyIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::RelatedContextPartyIDSource *) x));
}
static void *_p_FIX__UndlyInstrumentPartyIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::UndlyInstrumentPartyIDSource *) x));
}
static void *_p_FIX__RelatedPartyIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::RelatedPartyIDSource *) x));
}
static void *_p_FIX__Nested4PartyIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::Nested4PartyIDSource *) x));
}
static void *_p_FIX__RootPartyIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::RootPartyIDSource *) x));
}
static void *_p_FIX__PartyAltIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::PartyAltIDSource *) x));
}
static void *_p_FIX__ExDestinationIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::ExDestinationIDSource *) x));
}
static void *_p_FIX__Nested3PartyIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::Nested3PartyIDSource *) x));
}
static void *_p_FIX__TargetPartyIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::TargetPartyIDSource *) x));
}
static void *_p_FIX__InstrumentPartyIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::InstrumentPartyIDSource *) x));
}
static void *_p_FIX__SettlInstSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::SettlInstSource *) x));
}
static void *_p_FIX__ContextPartyIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::ContextPartyIDSource *) x));
}
static void *_p_FIX__NestedPartyIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::NestedPartyIDSource *) x));
}
static void *_p_FIX__CommTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::CommType *) x));
}
static void *_p_FIX__PartyIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::PartyIDSource *) x));
}
static void *_p_FIX__SettlPartyIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::SettlPartyIDSource *) x));
}
static void *_p_FIX__RefOrderIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::RefOrderIDSource *) x));
}
static void *_p_FIX__Nested2PartyIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::Nested2PartyIDSource *) x));
}
static void *_p_FIX__RelatedPartyAltIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::RelatedPartyAltIDSource *) x));
}
static void *_p_FIX__MassCancelResponseTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::MassCancelResponse *) x));
}
static void *_p_FIX__BenchmarkTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::Benchmark *) x));
}
static void *_p_FIX__TriggerOrderTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::TriggerOrderType *) x));
}
static void *_p_FIX__LegSettlTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::LegSettlType *) x));
}
static void *_p_FIX__LegSettlmntTypTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::LegSettlmntTyp *) x));
}
static void *_p_FIX__SettlmntTypTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::SettlmntTyp *) x));
}
static void *_p_FIX__PreallocMethodTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::PreallocMethod *) x));
}
static void *_p_FIX__ExerciseMethodTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::ExerciseMethod *) x));
}
static void *_p_FIX__AsOfIndicatorTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::AsOfIndicator *) x));
}
static void *_p_FIX__DisplayMethodTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::DisplayMethod *) x));
}
static void *_p_FIX__OrigTradeHandlingInstrTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::OrigTradeHandlingInstr *) x));
}
static void *_p_FIX__TradeHandlingInstrTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::TradeHandlingInstr *) x));
}
static void *_p_FIX__DeleteReasonTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::DeleteReason *) x));
}
static void *_p_FIX__DKReasonTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::DKReason *) x));
}
static void *_p_FIX__CancellationRightsTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::CancellationRights *) x));
}
static void *_p_FIX__CashMarginTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::CashMargin *) x));
}
static void *_p_FIX__Rule80ATo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::Rule80A *) x));
}
static void *_p_FIX__DayBookingInstTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::DayBookingInst *) x));
}
static void *_p_FIX__AdvSideTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::AdvSide *) x));
}
static void *_p_FIX__UnderlyingLegOptAttributeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::UnderlyingLegOptAttribute *) x));
}
static void *_p_FIX__OptAttributeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::OptAttribute *) x));
}
static void *_p_FIX__UnderlyingOptAttributeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::UnderlyingOptAttribute *) x));
}
static void *_p_FIX__IOIQltyIndTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::IOIQltyInd *) x));
}
static void *_p_FIX__DerivativeOptAttributeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::DerivativeOptAttribute *) x));
}
static void *_p_FIX__LegOptAttributeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::LegOptAttribute *) x));
}
static void *_p_FIX__SideTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::Side *) x));
}
static void *_p_FIX__TradSesUpdateActionTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::TradSesUpdateAction *) x));
}
static void *_p_FIX__SecurityUpdateActionTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::SecurityUpdateAction *) x));
}
static void *_p_FIX__ListUpdateActionTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::ListUpdateAction *) x));
}
static void *_p_FIX__OrdTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::OrdType *) x));
}
static void *_p_FIX__MarketUpdateActionTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::MarketUpdateAction *) x));
}
static void *_p_FIX__MDUpdateActionTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::MDUpdateAction *) x));
}
static void *_p_FIX__GroupTo_p_FIX__FieldMap(void *x) {
    return (void *)((FIX::FieldMap *)  ((FIX::Group *) x));
}
static void *_p_FIX__MessageTo_p_FIX__FieldMap(void *x) {
    return (void *)((FIX::FieldMap *)  ((FIX::Message *) x));
}
static void *_p_FIX__CFICodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CFICode *) x));
}
static void *_p_FIX__UnderlyingCFICodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingCFICode *) x));
}
static void *_p_FIX__DerivativeCFICodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeCFICode *) x));
}
static void *_p_FIX__LegCFICodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegCFICode *) x));
}
static void *_p_FIX__RiskCFICodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskCFICode *) x));
}
static void *_p_FIX__RelationshipRiskCFICodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskCFICode *) x));
}
static void *_p_FIX__MaturityMonthYearFormatTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MaturityMonthYearFormat *) x));
}
static void *_p_FIX__UnderlyingLegCFICodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegCFICode *) x));
}
static void *_p_FIX__StartCashTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StartCash *) x));
}
static void *_p_FIX__UnderlyingPriceUnitOfMeasureTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingPriceUnitOfMeasure *) x));
}
static void *_p_FIX__UnderlyingUnitOfMeasureTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingUnitOfMeasure *) x));
}
static void *_p_FIX__LegUnitOfMeasureTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegUnitOfMeasure *) x));
}
static void *_p_FIX__PriceUnitOfMeasureTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PriceUnitOfMeasure *) x));
}
static void *_p_FIX__UnitOfMeasureTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnitOfMeasure *) x));
}
static void *_p_FIX__DerivativePriceUnitOfMeasureTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativePriceUnitOfMeasure *) x));
}
static void *_p_FIX__LegPriceUnitOfMeasureTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegPriceUnitOfMeasure *) x));
}
static void *_p_FIX__DerivativeUnitOfMeasureTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeUnitOfMeasure *) x));
}
static void *_p_FIX__OrigTradeIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrigTradeID *) x));
}
static void *_p_FIX__FirmTradeIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::FirmTradeID *) x));
}
static void *_p_FIX__SecondaryFirmTradeIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryFirmTradeID *) x));
}
static void *_p_FIX__TradeIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeID *) x));
}
static void *_p_FIX__SecondaryTradeIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryTradeID *) x));
}
static void *_p_FIX__OrigSecondaryTradeIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrigSecondaryTradeID *) x));
}
static void *_p_FIX__UnderlyingSecurityTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSecurityType *) x));
}
static void *_p_FIX__SecurityTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityType *) x));
}
static void *_p_FIX__RepoCollateralSecurityTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RepoCollateralSecurityType *) x));
}
static void *_p_FIX__RiskSecurityTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskSecurityType *) x));
}
static void *_p_FIX__LegRepoCollateralSecurityTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegRepoCollateralSecurityType *) x));
}
static void *_p_FIX__ExpirationQtyTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ExpirationQtyType *) x));
}
static void *_p_FIX__UnderlyingLegSecurityTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSecurityType *) x));
}
static void *_p_FIX__LegSecurityTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSecurityType *) x));
}
static void *_p_FIX__QuantityTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuantityType *) x));
}
static void *_p_FIX__DerivativeSecurityTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityType *) x));
}
static void *_p_FIX__UnderlyingRepoCollateralSecurityTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingRepoCollateralSecurityType *) x));
}
static void *_p_FIX__QtyTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QtyType *) x));
}
static void *_p_FIX__AccountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Account *) x));
}
static void *_p_FIX__ClearingAccountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ClearingAccount *) x));
}
static void *_p_FIX__LegAllocAccountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegAllocAccount *) x));
}
static void *_p_FIX__AllocAccountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocAccount *) x));
}
static void *_p_FIX__RelationshipRiskSecurityTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskSecurityType *) x));
}
static void *_p_FIX__MDImplicitDeleteTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::MDImplicitDelete *) x));
}
static void *_p_FIX__LegTimeUnitTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegTimeUnit *) x));
}
static void *_p_FIX__TimeUnitTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TimeUnit *) x));
}
static void *_p_FIX__DerivativeTimeUnitTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeTimeUnit *) x));
}
static void *_p_FIX__UnderlyingTimeUnitTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingTimeUnit *) x));
}
static void *_p_FIX__StandInstDbIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StandInstDbID *) x));
}
static void *_p_FIX__NotifyBrokerOfCreditTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::NotifyBrokerOfCredit *) x));
}
static void *_p_FIX__BrokerOfCreditTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BrokerOfCredit *) x));
}
static void *_p_FIX__UnderlyingSecuritySubTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSecuritySubType *) x));
}
static void *_p_FIX__RiskSecuritySubTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskSecuritySubType *) x));
}
static void *_p_FIX__LegSecuritySubTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSecuritySubType *) x));
}
static void *_p_FIX__DerivativeSecuritySubTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecuritySubType *) x));
}
static void *_p_FIX__RelationshipRiskSecuritySubTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskSecuritySubType *) x));
}
static void *_p_FIX__SecuritySubTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecuritySubType *) x));
}
static void *_p_FIX__UnderlyingLegSecuritySubTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSecuritySubType *) x));
}
static void *_p_FIX__TrdSubTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TrdSubType *) x));
}
static void *_p_FIX__ShortSaleReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ShortSaleReason *) x));
}
static void *_p_FIX__DeleteReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DeleteReason *) x));
}
static void *_p_FIX__AllocCancReplaceReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocCancReplaceReason *) x));
}
static void *_p_FIX__DKReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DKReason *) x));
}
static void *_p_FIX__NetworkRequestIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NetworkRequestID *) x));
}
static void *_p_FIX__TradeRequestIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeRequestID *) x));
}
static void *_p_FIX__UserRequestIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UserRequestID *) x));
}
static void *_p_FIX__MarginExcessTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MarginExcess *) x));
}
static void *_p_FIX__PartyDetailsListRequestIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PartyDetailsListRequestID *) x));
}
static void *_p_FIX__RegistRejReasonTextTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RegistRejReasonText *) x));
}
static void *_p_FIX__ContraTradeTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::ContraTradeTime *) x));
}
static void *_p_FIX__NoEventsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoEvents *) x));
}
static void *_p_FIX__NoDerivativeEventsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoDerivativeEvents *) x));
}
static void *_p_FIX__BidPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BidPx *) x));
}
static void *_p_FIX__CalculatedCcyLastQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CalculatedCcyLastQty *) x));
}
static void *_p_FIX__LastQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LastQty *) x));
}
static void *_p_FIX__SideLastQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SideLastQty *) x));
}
static void *_p_FIX__LegCalculatedCcyLastQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegCalculatedCcyLastQty *) x));
}
static void *_p_FIX__LegLastQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegLastQty *) x));
}
static void *_p_FIX__DeskIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DeskID *) x));
}
static void *_p_FIX__CheckSumFieldTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *)  ((FIX::CheckSumField *) x));
}
static void *_p_FIX__UnderlyingLastQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingLastQty *) x));
}
static void *_p_FIX__UsernameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Username *) x));
}
static void *_p_FIX__PosMaintRptIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PosMaintRptID *) x));
}
static void *_p_FIX__ContIntRptIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ContIntRptID *) x));
}
static void *_p_FIX__DerivativeStrikeValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeStrikeValue *) x));
}
static void *_p_FIX__StrikeValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StrikeValue *) x));
}
static void *_p_FIX__OptPayoutTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::OptPayoutType *) x));
}
static void *_p_FIX__EncodedTextTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedText *) x));
}
static void *_p_FIX__GapFillFlagTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::GapFillFlag *) x));
}
static void *_p_FIX__MarketDepthTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MarketDepth *) x));
}
static void *_p_FIX__MDPriceLevelTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDPriceLevel *) x));
}
static void *_p_FIX__QuoteResponseLevelTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteResponseLevel *) x));
}
static void *_p_FIX__YieldCalcDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::YieldCalcDate *) x));
}
static void *_p_FIX__CollRptIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CollRptID *) x));
}
static void *_p_FIX__LegNumberTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegNumber *) x));
}
static void *_p_FIX__PosTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PosType *) x));
}
static void *_p_FIX__ContAmtTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ContAmtType *) x));
}
static void *_p_FIX__PosAmtTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PosAmtType *) x));
}
static void *_p_FIX__SettlInstIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlInstID *) x));
}
static void *_p_FIX__ReportedPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ReportedPx *) x));
}
static void *_p_FIX__LastFragmentTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::LastFragment *) x));
}
static void *_p_FIX__PriceLimitTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PriceLimitType *) x));
}
static void *_p_FIX__RiskLimitTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RiskLimitType *) x));
}
static void *_p_FIX__PegLimitTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PegLimitType *) x));
}
static void *_p_FIX__RelationshipRiskLimitTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RelationshipRiskLimitType *) x));
}
static void *_p_FIX__SecondaryPriceLimitTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecondaryPriceLimitType *) x));
}
static void *_p_FIX__DiscretionLimitTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DiscretionLimitType *) x));
}
static void *_p_FIX__NoLegStipulationsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoLegStipulations *) x));
}
static void *_p_FIX__NoStipulationsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoStipulations *) x));
}
static void *_p_FIX__ShortQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ShortQty *) x));
}
static void *_p_FIX__SellerDaysTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SellerDays *) x));
}
static void *_p_FIX__DiscretionOffsetTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DiscretionOffsetType *) x));
}
static void *_p_FIX__PegOffsetTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PegOffsetType *) x));
}
static void *_p_FIX__TradSesEndTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::TradSesEndTime *) x));
}
static void *_p_FIX__ComplexEventEndTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeOnlyField *) ((FIX::ComplexEventEndTime *) x));
}
static void *_p_FIX__TierCodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TierCode *) x));
}
static void *_p_FIX__SpreadToBenchmarkTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SpreadToBenchmark *) x));
}
static void *_p_FIX__TransferReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TransferReason *) x));
}
static void *_p_FIX__CollAsgnRejectReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollAsgnRejectReason *) x));
}
static void *_p_FIX__QuoteRequestRejectReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteRequestRejectReason *) x));
}
static void *_p_FIX__SessionRejectReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SessionRejectReason *) x));
}
static void *_p_FIX__ListRejectReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ListRejectReason *) x));
}
static void *_p_FIX__QuoteRejectReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteRejectReason *) x));
}
static void *_p_FIX__TradeReportRejectReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradeReportRejectReason *) x));
}
static void *_p_FIX__StreamAsgnRejReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StreamAsgnRejReason *) x));
}
static void *_p_FIX__QuoteEntryRejectReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteEntryRejectReason *) x));
}
static void *_p_FIX__ExecRestatementReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ExecRestatementReason *) x));
}
static void *_p_FIX__OrdRejReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::OrdRejReason *) x));
}
static void *_p_FIX__CollAsgnReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollAsgnReason *) x));
}
static void *_p_FIX__MassCancelRejectReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MassCancelRejectReason *) x));
}
static void *_p_FIX__TradSesStatusRejReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradSesStatusRejReason *) x));
}
static void *_p_FIX__CxlRejReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CxlRejReason *) x));
}
static void *_p_FIX__ConfirmRejReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ConfirmRejReason *) x));
}
static void *_p_FIX__MassActionRejectReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MassActionRejectReason *) x));
}
static void *_p_FIX__BenchmarkTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::Benchmark *) x));
}
static void *_p_FIX__RefOrdIDReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RefOrdIDReason *) x));
}
static void *_p_FIX__MDReqRejReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MDReqRejReason *) x));
}
static void *_p_FIX__BusinessRejectReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::BusinessRejectReason *) x));
}
static void *_p_FIX__AllocTextTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocText *) x));
}
static void *_p_FIX__EncodedAllocTextTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedAllocText *) x));
}
static void *_p_FIX__DeliverToSubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DeliverToSubID *) x));
}
static void *_p_FIX__MiscFeeCurrTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MiscFeeCurr *) x));
}
static void *_p_FIX__SettlObligMsgIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlObligMsgID *) x));
}
static void *_p_FIX__ReportedPxDiffTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ReportedPxDiff *) x));
}
static void *_p_FIX__NoComplexEventsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoComplexEvents *) x));
}
static void *_p_FIX__NoNestedInstrAttribTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNestedInstrAttrib *) x));
}
static void *_p_FIX__NoInstrAttribTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoInstrAttrib *) x));
}
static void *_p_FIX__NoDerivativeInstrAttribTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoDerivativeInstrAttrib *) x));
}
static void *_p_FIX__NoTrdRepIndicatorsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoTrdRepIndicators *) x));
}
static void *_p_FIX__NoStatsIndicatorsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoStatsIndicators *) x));
}
static void *_p_FIX__NoQuoteSetsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoQuoteSets *) x));
}
static void *_p_FIX__BeginSeqNoTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::BeginSeqNo *) x));
}
static void *_p_FIX__EventPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::EventPx *) x));
}
static void *_p_FIX__DerivativeEventPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeEventPx *) x));
}
static void *_p_FIX__StopPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StopPx *) x));
}
static void *_p_FIX__SecurityTradingEventTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityTradingEvent *) x));
}
static void *_p_FIX__CrossTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CrossType *) x));
}
static void *_p_FIX__EndStrikePxRangeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::EndStrikePxRange *) x));
}
static void *_p_FIX__StartStrikePxRangeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StartStrikePxRange *) x));
}
static void *_p_FIX__AgreementDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AgreementDesc *) x));
}
static void *_p_FIX__MarketSegmentDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MarketSegmentDesc *) x));
}
static void *_p_FIX__OrderDelayTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::OrderDelay *) x));
}
static void *_p_FIX__OrderCategoryTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::OrderCategory *) x));
}
static void *_p_FIX__NewsCategoryTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NewsCategory *) x));
}
static void *_p_FIX__CardNumberTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CardNumber *) x));
}
static void *_p_FIX__CashDistribAgentAcctNumberTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashDistribAgentAcctNumber *) x));
}
static void *_p_FIX__NoPositionsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoPositions *) x));
}
static void *_p_FIX__NoUnderlyingsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoUnderlyings *) x));
}
static void *_p_FIX__NoOfLegUnderlyingsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoOfLegUnderlyings *) x));
}
static void *_p_FIX__NoDatesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoDates *) x));
}
static void *_p_FIX__CardStartDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CardStartDate *) x));
}
static void *_p_FIX__StartDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StartDate *) x));
}
static void *_p_FIX__ComplexEventStartDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::ComplexEventStartDate *) x));
}
static void *_p_FIX__RefreshQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RefreshQty *) x));
}
static void *_p_FIX__OrigTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::OrigTime *) x));
}
static void *_p_FIX__MDUpdateTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDUpdateType *) x));
}
static void *_p_FIX__MDQuoteTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDQuoteType *) x));
}
static void *_p_FIX__QuoteTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteType *) x));
}
static void *_p_FIX__NumBiddersTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NumBidders *) x));
}
static void *_p_FIX__AgreementDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AgreementDate *) x));
}
static void *_p_FIX__EventDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EventDate *) x));
}
static void *_p_FIX__UnderlyingCouponPaymentDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingCouponPaymentDate *) x));
}
static void *_p_FIX__PaymentDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PaymentDate *) x));
}
static void *_p_FIX__UnderlyingSettlementDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSettlementDate *) x));
}
static void *_p_FIX__CouponPaymentDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CouponPaymentDate *) x));
}
static void *_p_FIX__DerivativeEventDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeEventDate *) x));
}
static void *_p_FIX__LegCouponPaymentDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegCouponPaymentDate *) x));
}
static void *_p_FIX__SymbolSfxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SymbolSfx *) x));
}
static void *_p_FIX__UnderlyingLegSymbolSfxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSymbolSfx *) x));
}
static void *_p_FIX__RiskSymbolSfxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskSymbolSfx *) x));
}
static void *_p_FIX__DerivativeSymbolSfxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSymbolSfx *) x));
}
static void *_p_FIX__UnderlyingSymbolSfxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSymbolSfx *) x));
}
static void *_p_FIX__LegSymbolSfxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSymbolSfx *) x));
}
static void *_p_FIX__RelationshipRiskSymbolSfxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskSymbolSfx *) x));
}
static void *_p_FIX__TrdTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TrdType *) x));
}
static void *_p_FIX__SecondaryTrdTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecondaryTrdType *) x));
}
static void *_p_FIX__RptSeqTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RptSeq *) x));
}
static void *_p_FIX__NoMsgTypesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoMsgTypes *) x));
}
static void *_p_FIX__TriggerOrderTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TriggerOrderType *) x));
}
static void *_p_FIX__StrategyParameterTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StrategyParameterType *) x));
}
static void *_p_FIX__OwnerTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::OwnerType *) x));
}
static void *_p_FIX__SettlSessSubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlSessSubID *) x));
}
static void *_p_FIX__TickRuleTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TickRuleType *) x));
}
static void *_p_FIX__UnderlyingFlowScheduleTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingFlowScheduleType *) x));
}
static void *_p_FIX__LegFlowScheduleTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegFlowScheduleType *) x));
}
static void *_p_FIX__DerivativeFlowScheduleTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeFlowScheduleType *) x));
}
static void *_p_FIX__FlowScheduleTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::FlowScheduleType *) x));
}
static void *_p_FIX__MiscFeeBasisTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MiscFeeBasis *) x));
}
static void *_p_FIX__EncodedTextLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedTextLen *) x));
}
static void *_p_FIX__EncodedAllocTextLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedAllocTextLen *) x));
}
static void *_p_FIX__TradSesEventTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradSesEvent *) x));
}
static void *_p_FIX__EncodedListStatusTextLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedListStatusTextLen *) x));
}
static void *_p_FIX__DisplayQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DisplayQty *) x));
}
static void *_p_FIX__SecondaryDisplayQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SecondaryDisplayQty *) x));
}
static void *_p_FIX__TotNumTradeReportsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNumTradeReports *) x));
}
static void *_p_FIX__TotalNumPosReportsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotalNumPosReports *) x));
}
static void *_p_FIX__TotNumReportsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNumReports *) x));
}
static void *_p_FIX__TotNumAssignmentReportsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNumAssignmentReports *) x));
}
static void *_p_FIX__SideSettlCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SideSettlCurrency *) x));
}
static void *_p_FIX__LegBenchmarkCurveCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegBenchmarkCurveCurrency *) x));
}
static void *_p_FIX__BenchmarkCurveCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BenchmarkCurveCurrency *) x));
}
static void *_p_FIX__LegAllocSettlCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegAllocSettlCurrency *) x));
}
static void *_p_FIX__PositionCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PositionCurrency *) x));
}
static void *_p_FIX__UnderlyingCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingCurrency *) x));
}
static void *_p_FIX__LegSettlCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSettlCurrency *) x));
}
static void *_p_FIX__TradingCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradingCurrency *) x));
}
static void *_p_FIX__StrikeCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StrikeCurrency *) x));
}
static void *_p_FIX__SettlCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlCurrency *) x));
}
static void *_p_FIX__CurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Currency *) x));
}
static void *_p_FIX__LegCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegCurrency *) x));
}
static void *_p_FIX__SideCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SideCurrency *) x));
}
static void *_p_FIX__AllocSettlCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocSettlCurrency *) x));
}
static void *_p_FIX__AgreementCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AgreementCurrency *) x));
}
static void *_p_FIX__DerivativeStrikeCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeStrikeCurrency *) x));
}
static void *_p_FIX__UnderlyingStrikeCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingStrikeCurrency *) x));
}
static void *_p_FIX__CommCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CommCurrency *) x));
}
static void *_p_FIX__RiskLimitCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskLimitCurrency *) x));
}
static void *_p_FIX__RelationshipRiskLimitCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskLimitCurrency *) x));
}
static void *_p_FIX__LegStrikeCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegStrikeCurrency *) x));
}
static void *_p_FIX__BidTradeTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::BidTradeType *) x));
}
static void *_p_FIX__TradeTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TradeType *) x));
}
static void *_p_FIX__SettleOnOpenFlagTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettleOnOpenFlag *) x));
}
static void *_p_FIX__DerivativeSettleOnOpenFlagTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSettleOnOpenFlag *) x));
}
static void *_p_FIX__LocaleOfIssueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LocaleOfIssue *) x));
}
static void *_p_FIX__UnderlyingCountryOfIssueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingCountryOfIssue *) x));
}
static void *_p_FIX__LegStateOrProvinceOfIssueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegStateOrProvinceOfIssue *) x));
}
static void *_p_FIX__UnderlyingStateOrProvinceOfIssueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingStateOrProvinceOfIssue *) x));
}
static void *_p_FIX__DerivativeCountryOfIssueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeCountryOfIssue *) x));
}
static void *_p_FIX__DerivativeStateOrProvinceOfIssueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeStateOrProvinceOfIssue *) x));
}
static void *_p_FIX__LegCountryOfIssueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegCountryOfIssue *) x));
}
static void *_p_FIX__LegLocaleOfIssueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegLocaleOfIssue *) x));
}
static void *_p_FIX__StateOrProvinceOfIssueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StateOrProvinceOfIssue *) x));
}
static void *_p_FIX__CountryOfIssueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CountryOfIssue *) x));
}
static void *_p_FIX__DerivativeLocaleOfIssueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeLocaleOfIssue *) x));
}
static void *_p_FIX__UnderlyingLocaleOfIssueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLocaleOfIssue *) x));
}
static void *_p_FIX__NoSettlInstTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSettlInst *) x));
}
static void *_p_FIX__NoTradingSessionsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoTradingSessions *) x));
}
static void *_p_FIX__RelationshipRiskSeniorityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskSeniority *) x));
}
static void *_p_FIX__RiskSeniorityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskSeniority *) x));
}
static void *_p_FIX__UnderlyingSeniorityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSeniority *) x));
}
static void *_p_FIX__SeniorityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Seniority *) x));
}
static void *_p_FIX__NoExecInstRulesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoExecInstRules *) x));
}
static void *_p_FIX__TimeBracketTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TimeBracket *) x));
}
static void *_p_FIX__PriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Price *) x));
}
static void *_p_FIX__SettlInstModeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlInstMode *) x));
}
static void *_p_FIX__ApplResponseErrorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplResponseError *) x));
}
static void *_p_FIX__HaltReasonIntTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::HaltReasonInt *) x));
}
static void *_p_FIX__ListNoOrdsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ListNoOrds *) x));
}
static void *_p_FIX__LegSettlmntTypTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::LegSettlmntTyp *) x));
}
static void *_p_FIX__SettlmntTypTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlmntTyp *) x));
}
static void *_p_FIX__MinQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MinQty *) x));
}
static void *_p_FIX__ScopeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Scope *) x));
}
static void *_p_FIX__AdvRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AdvRefID *) x));
}
static void *_p_FIX__BookingUnitTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::BookingUnit *) x));
}
static void *_p_FIX__LegLastPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegLastPx *) x));
}
static void *_p_FIX__UnderlyingLastPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingLastPx *) x));
}
static void *_p_FIX__PrevClosePxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PrevClosePx *) x));
}
static void *_p_FIX__MDReportIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDReportID *) x));
}
static void *_p_FIX__SecurityReportIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityReportID *) x));
}
static void *_p_FIX__PartyDetailsListReportIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PartyDetailsListReportID *) x));
}
static void *_p_FIX__SecondaryTradeReportIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryTradeReportID *) x));
}
static void *_p_FIX__ApplReportIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ApplReportID *) x));
}
static void *_p_FIX__MassActionReportIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MassActionReportID *) x));
}
static void *_p_FIX__MarketReportIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MarketReportID *) x));
}
static void *_p_FIX__LegReportIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegReportID *) x));
}
static void *_p_FIX__TradeReportIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeReportID *) x));
}
static void *_p_FIX__AllocReportIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocReportID *) x));
}
static void *_p_FIX__SideTradeReportIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SideTradeReportID *) x));
}
static void *_p_FIX__CancellationRightsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::CancellationRights *) x));
}
static void *_p_FIX__SecurityXMLTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityXML *) x));
}
static void *_p_FIX__DerivativeSecurityXMLTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityXML *) x));
}
static void *_p_FIX__NoMatchRulesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoMatchRules *) x));
}
static void *_p_FIX__RawDataTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RawData *) x));
}
static void *_p_FIX__AllocHandlInstTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocHandlInst *) x));
}
static void *_p_FIX__HandlInstTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::HandlInst *) x));
}
static void *_p_FIX__OrdTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::OrdType *) x));
}
static void *_p_FIX__UnderlyingFactorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingFactor *) x));
}
static void *_p_FIX__LegFactorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegFactor *) x));
}
static void *_p_FIX__MatchTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MatchType *) x));
}
static void *_p_FIX__UnderlyingIssueDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingIssueDate *) x));
}
static void *_p_FIX__DerivativeIssueDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeIssueDate *) x));
}
static void *_p_FIX__IssueDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::IssueDate *) x));
}
static void *_p_FIX__LegIssueDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegIssueDate *) x));
}
static void *_p_FIX__TriggerTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TriggerType *) x));
}
static void *_p_FIX__NoUnderlyingAmountsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoUnderlyingAmounts *) x));
}
static void *_p_FIX__RelationshipRiskInstrumentSettlTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskInstrumentSettlType *) x));
}
static void *_p_FIX__SettlTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlType *) x));
}
static void *_p_FIX__LegSettlTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::LegSettlType *) x));
}
static void *_p_FIX__RiskInstrumentSettlTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskInstrumentSettlType *) x));
}
static void *_p_FIX__LiquidityIndTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LiquidityIndType *) x));
}
static void *_p_FIX__ConfirmTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ConfirmType *) x));
}
static void *_p_FIX__AllocAvgPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllocAvgPx *) x));
}
static void *_p_FIX__SecurityReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityReqID *) x));
}
static void *_p_FIX__CollApplTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollApplType *) x));
}
static void *_p_FIX__CashMarginTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::CashMargin *) x));
}
static void *_p_FIX__UnderlyingAllocationPercentTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingAllocationPercent *) x));
}
static void *_p_FIX__RiskWarningLevelPercentTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RiskWarningLevelPercent *) x));
}
static void *_p_FIX__OrderPercentTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OrderPercent *) x));
}
static void *_p_FIX__CrossPercentTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CrossPercent *) x));
}
static void *_p_FIX__RelationshipRiskWarningLevelPercentTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RelationshipRiskWarningLevelPercent *) x));
}
static void *_p_FIX__TradSesStartTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::TradSesStartTime *) x));
}
static void *_p_FIX__ComplexEventStartTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeOnlyField *) ((FIX::ComplexEventStartTime *) x));
}
static void *_p_FIX__EncodedListExecInstLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedListExecInstLen *) x));
}
static void *_p_FIX__EventTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::EventTime *) x));
}
static void *_p_FIX__DerivativeEventTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::DerivativeEventTime *) x));
}
static void *_p_FIX__UndlyInstrumentPartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UndlyInstrumentPartyRole *) x));
}
static void *_p_FIX__RootPartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RootPartyRole *) x));
}
static void *_p_FIX__ContextPartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ContextPartyRole *) x));
}
static void *_p_FIX__TrdRepPartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TrdRepPartyRole *) x));
}
static void *_p_FIX__InstrumentPartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::InstrumentPartyRole *) x));
}
static void *_p_FIX__RequestedPartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RequestedPartyRole *) x));
}
static void *_p_FIX__Nested4PartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::Nested4PartyRole *) x));
}
static void *_p_FIX__NestedPartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NestedPartyRole *) x));
}
static void *_p_FIX__Nested3PartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::Nested3PartyRole *) x));
}
static void *_p_FIX__RelatedPartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RelatedPartyRole *) x));
}
static void *_p_FIX__DerivativeInstrumentPartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeInstrumentPartyRole *) x));
}
static void *_p_FIX__PartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PartyRole *) x));
}
static void *_p_FIX__RelatedContextPartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RelatedContextPartyRole *) x));
}
static void *_p_FIX__SettlPartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SettlPartyRole *) x));
}
static void *_p_FIX__Nested2PartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::Nested2PartyRole *) x));
}
static void *_p_FIX__TargetPartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TargetPartyRole *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingInstrumentPartyRole *) x));
}
static void *_p_FIX__CashDistribAgentCodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashDistribAgentCode *) x));
}
static void *_p_FIX__LegCreditRatingTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegCreditRating *) x));
}
static void *_p_FIX__CreditRatingTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CreditRating *) x));
}
static void *_p_FIX__SecuritySettlAgentCodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecuritySettlAgentCode *) x));
}
static void *_p_FIX__CashSettlAgentCodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashSettlAgentCode *) x));
}
static void *_p_FIX__UnderlyingCreditRatingTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingCreditRating *) x));
}
static void *_p_FIX__CxlQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CxlQty *) x));
}
static void *_p_FIX__UnderlyingCashTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingCashType *) x));
}
static void *_p_FIX__ConfirmReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ConfirmReqID *) x));
}
static void *_p_FIX__NoBidDescriptorsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoBidDescriptors *) x));
}
static void *_p_FIX__LegDividendYieldTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegDividendYield *) x));
}
static void *_p_FIX__DividendYieldTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DividendYield *) x));
}
static void *_p_FIX__SecurityResponseIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityResponseID *) x));
}
static void *_p_FIX__LastNetworkResponseIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LastNetworkResponseID *) x));
}
static void *_p_FIX__NetworkResponseIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NetworkResponseID *) x));
}
static void *_p_FIX__ApplResponseIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ApplResponseID *) x));
}
static void *_p_FIX__MultilegModelTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MultilegModel *) x));
}
static void *_p_FIX__ContraTradeQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ContraTradeQty *) x));
}
static void *_p_FIX__InViewOfCommonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::InViewOfCommon *) x));
}
static void *_p_FIX__CrossPrioritizationTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CrossPrioritization *) x));
}
static void *_p_FIX__LastPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LastPx *) x));
}
static void *_p_FIX__DisplayLowQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DisplayLowQty *) x));
}
static void *_p_FIX__RateSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RateSource *) x));
}
static void *_p_FIX__SecurityListTypeSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityListTypeSource *) x));
}
static void *_p_FIX__SettlObligSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlObligSource *) x));
}
static void *_p_FIX__LegCoveredOrUncoveredTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegCoveredOrUncovered *) x));
}
static void *_p_FIX__CoveredOrUncoveredTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CoveredOrUncovered *) x));
}
static void *_p_FIX__QuoteReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuoteReqID *) x));
}
static void *_p_FIX__DeskTypeSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DeskTypeSource *) x));
}
static void *_p_FIX__TriggerPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TriggerPrice *) x));
}
static void *_p_FIX__FloorPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::FloorPrice *) x));
}
static void *_p_FIX__PutOrCallTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PutOrCall *) x));
}
static void *_p_FIX__RiskPutOrCallTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RiskPutOrCall *) x));
}
static void *_p_FIX__LegPutOrCallTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegPutOrCall *) x));
}
static void *_p_FIX__UnderlyingLegPutOrCallTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingLegPutOrCall *) x));
}
static void *_p_FIX__DerivativePutOrCallTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativePutOrCall *) x));
}
static void *_p_FIX__DerivativeFloorPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeFloorPrice *) x));
}
static void *_p_FIX__RelationshipRiskPutOrCallTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RelationshipRiskPutOrCall *) x));
}
static void *_p_FIX__UnderlyingPutOrCallTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingPutOrCall *) x));
}
static void *_p_FIX__NoLegsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoLegs *) x));
}
static void *_p_FIX__CashSettlAgentAcctNumTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashSettlAgentAcctNum *) x));
}
static void *_p_FIX__SecuritySettlAgentAcctNumTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecuritySettlAgentAcctNum *) x));
}
static void *_p_FIX__StandInstDbNameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StandInstDbName *) x));
}
static void *_p_FIX__RiskFreeRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RiskFreeRate *) x));
}
static void *_p_FIX__QuoteRespIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuoteRespID *) x));
}
static void *_p_FIX__YieldRedemptionPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::YieldRedemptionPrice *) x));
}
static void *_p_FIX__DiscretionPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DiscretionPrice *) x));
}
static void *_p_FIX__CxlTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::CxlType *) x));
}
static void *_p_FIX__CPRegTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CPRegType *) x));
}
static void *_p_FIX__FactorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Factor *) x));
}
static void *_p_FIX__NoExpirationTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoExpiration *) x));
}
static void *_p_FIX__CollAsgnRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CollAsgnRefID *) x));
}
static void *_p_FIX__TimeToExpirationTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TimeToExpiration *) x));
}
static void *_p_FIX__UnderlyingCPRegTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingCPRegType *) x));
}
static void *_p_FIX__OwnershipTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::OwnershipType *) x));
}
static void *_p_FIX__UnderlyingStipTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingStipType *) x));
}
static void *_p_FIX__PriceProtectionScopeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::PriceProtectionScope *) x));
}
static void *_p_FIX__MassActionScopeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MassActionScope *) x));
}
static void *_p_FIX__DiscretionScopeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DiscretionScope *) x));
}
static void *_p_FIX__ResponseDestinationTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ResponseDestination *) x));
}
static void *_p_FIX__ExDestinationTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExDestination *) x));
}
static void *_p_FIX__DesignationTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Designation *) x));
}
static void *_p_FIX__TradSesOpenTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::TradSesOpenTime *) x));
}
static void *_p_FIX__NoUnderlyingStipsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoUnderlyingStips *) x));
}
static void *_p_FIX__PeggedRefPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PeggedRefPrice *) x));
}
static void *_p_FIX__LegOptionRatioTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegOptionRatio *) x));
}
static void *_p_FIX__MarginRatioTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MarginRatio *) x));
}
static void *_p_FIX__UrgencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::Urgency *) x));
}
static void *_p_FIX__LowPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LowPx *) x));
}
static void *_p_FIX__PaymentRefTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PaymentRef *) x));
}
static void *_p_FIX__ExchangeForPhysicalTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ExchangeForPhysical *) x));
}
static void *_p_FIX__DefOfferSizeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DefOfferSize *) x));
}
static void *_p_FIX__OfferSizeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OfferSize *) x));
}
static void *_p_FIX__MinOfferSizeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MinOfferSize *) x));
}
static void *_p_FIX__EncodedMktSegmDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedMktSegmDesc *) x));
}
static void *_p_FIX__RFQReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RFQReqID *) x));
}
static void *_p_FIX__SideQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SideQty *) x));
}
static void *_p_FIX__AllocSettlCurrAmtTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllocSettlCurrAmt *) x));
}
static void *_p_FIX__SettlCurrAmtTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SettlCurrAmt *) x));
}
static void *_p_FIX__XmlDataTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::XmlData *) x));
}
static void *_p_FIX__NumTicketsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NumTickets *) x));
}
static void *_p_FIX__NoRptsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRpts *) x));
}
static void *_p_FIX__IOINaturalFlagTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::IOINaturalFlag *) x));
}
static void *_p_FIX__TradeConditionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeCondition *) x));
}
static void *_p_FIX__ComplexEventConditionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ComplexEventCondition *) x));
}
static void *_p_FIX__QuoteConditionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuoteCondition *) x));
}
static void *_p_FIX__BidYieldTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BidYield *) x));
}
static void *_p_FIX__MidYieldTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MidYield *) x));
}
static void *_p_FIX__NetGrossIndTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NetGrossInd *) x));
}
static void *_p_FIX__ExecValuationPointTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::ExecValuationPoint *) x));
}
static void *_p_FIX__AffectedOrderIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AffectedOrderID *) x));
}
static void *_p_FIX__OrderIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrderID *) x));
}
static void *_p_FIX__NotAffectedOrderIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NotAffectedOrderID *) x));
}
static void *_p_FIX__AffectedSecondaryOrderIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AffectedSecondaryOrderID *) x));
}
static void *_p_FIX__SecondaryOrderIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryOrderID *) x));
}
static void *_p_FIX__RefOrderIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefOrderID *) x));
}
static void *_p_FIX__ReferencePageTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ReferencePage *) x));
}
static void *_p_FIX__UnderlyingSecurityIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSecurityIDSource *) x));
}
static void *_p_FIX__PartyIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::PartyIDSource *) x));
}
static void *_p_FIX__InputSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::InputSource *) x));
}
static void *_p_FIX__PegSecurityIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PegSecurityIDSource *) x));
}
static void *_p_FIX__TriggerSecurityIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TriggerSecurityIDSource *) x));
}
static void *_p_FIX__LegSecurityAltIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSecurityAltIDSource *) x));
}
static void *_p_FIX__RelationshipRiskSecurityAltIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskSecurityAltIDSource *) x));
}
static void *_p_FIX__NestedPartyIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::NestedPartyIDSource *) x));
}
static void *_p_FIX__UnderlyingIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingIDSource *) x));
}
static void *_p_FIX__ContextPartyIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ContextPartyIDSource *) x));
}
static void *_p_FIX__SecurityAltIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityAltIDSource *) x));
}
static void *_p_FIX__UnderlyingLegSecurityAltIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSecurityAltIDSource *) x));
}
static void *_p_FIX__SecurityIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityIDSource *) x));
}
static void *_p_FIX__DerivativeInstrumentPartyIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeInstrumentPartyIDSource *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartyIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::UnderlyingInstrumentPartyIDSource *) x));
}
static void *_p_FIX__RiskSecurityAltIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskSecurityAltIDSource *) x));
}
static void *_p_FIX__NoAltMDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoAltMDSource *) x));
}
static void *_p_FIX__RelationshipRiskSecurityIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskSecurityIDSource *) x));
}
static void *_p_FIX__RelatedContextPartyIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::RelatedContextPartyIDSource *) x));
}
static void *_p_FIX__MessageEventSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MessageEventSource *) x));
}
static void *_p_FIX__UndlyInstrumentPartyIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::UndlyInstrumentPartyIDSource *) x));
}
static void *_p_FIX__ExDestinationIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ExDestinationIDSource *) x));
}
static void *_p_FIX__OrderHandlingInstSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::OrderHandlingInstSource *) x));
}
static void *_p_FIX__BenchmarkSecurityIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BenchmarkSecurityIDSource *) x));
}
static void *_p_FIX__DerivativeSecurityIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityIDSource *) x));
}
static void *_p_FIX__AcctIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AcctIDSource *) x));
}
static void *_p_FIX__Nested4PartyIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::Nested4PartyIDSource *) x));
}
static void *_p_FIX__RiskSecurityIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskSecurityIDSource *) x));
}
static void *_p_FIX__RootPartyIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::RootPartyIDSource *) x));
}
static void *_p_FIX__PartyAltIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::PartyAltIDSource *) x));
}
static void *_p_FIX__DerivativeSecurityAltIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityAltIDSource *) x));
}
static void *_p_FIX__Nested3PartyIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::Nested3PartyIDSource *) x));
}
static void *_p_FIX__IDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::IDSource *) x));
}
static void *_p_FIX__TargetPartyIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TargetPartyIDSource *) x));
}
static void *_p_FIX__InstrumentPartyIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::InstrumentPartyIDSource *) x));
}
static void *_p_FIX__LegSecurityIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSecurityIDSource *) x));
}
static void *_p_FIX__SettlInstSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlInstSource *) x));
}
static void *_p_FIX__TradeInputSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeInputSource *) x));
}
static void *_p_FIX__RelatedPartyIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::RelatedPartyIDSource *) x));
}
static void *_p_FIX__ApplTotalMessageCountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplTotalMessageCount *) x));
}
static void *_p_FIX__AllocAcctIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocAcctIDSource *) x));
}
static void *_p_FIX__SettlPartyIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlPartyIDSource *) x));
}
static void *_p_FIX__RefOrderIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::RefOrderIDSource *) x));
}
static void *_p_FIX__Nested2PartyIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::Nested2PartyIDSource *) x));
}
static void *_p_FIX__LegAllocAcctIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegAllocAcctIDSource *) x));
}
static void *_p_FIX__RelatedPartyAltIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::RelatedPartyAltIDSource *) x));
}
static void *_p_FIX__UnderlyingSecurityAltIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSecurityAltIDSource *) x));
}
static void *_p_FIX__UnderlyingLegSecurityIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSecurityIDSource *) x));
}
static void *_p_FIX__FairValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::FairValue *) x));
}
static void *_p_FIX__StrategyParameterValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StrategyParameterValue *) x));
}
static void *_p_FIX__LegalConfirmTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::LegalConfirm *) x));
}
static void *_p_FIX__ContractSettlMonthTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ContractSettlMonth *) x));
}
static void *_p_FIX__LegContractSettlMonthTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegContractSettlMonth *) x));
}
static void *_p_FIX__QuoteIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuoteID *) x));
}
static void *_p_FIX__DerivativeContractSettlMonthTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeContractSettlMonth *) x));
}
static void *_p_FIX__TransBkdTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::TransBkdTime *) x));
}
static void *_p_FIX__CollRespIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CollRespID *) x));
}
static void *_p_FIX__SideTrdRegTimestampTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SideTrdRegTimestampType *) x));
}
static void *_p_FIX__TrdRegTimestampTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TrdRegTimestampType *) x));
}
static void *_p_FIX__LegStipulationValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegStipulationValue *) x));
}
static void *_p_FIX__StipulationValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StipulationValue *) x));
}
static void *_p_FIX__CharFieldTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *)  ((FIX::CharField *) x));
}
static void *_p_FIX__TradSesModeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradSesMode *) x));
}
static void *_p_FIX__CountryTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Country *) x));
}
static void *_p_FIX__MDEntryDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcDateField *) ((FIX::MDEntryDate *) x));
}
static void *_p_FIX__Rule80ATo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::Rule80A *) x));
}
static void *_p_FIX__NoDerivativeInstrumentPartiesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoDerivativeInstrumentParties *) x));
}
static void *_p_FIX__NoUndlyInstrumentPartiesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoUndlyInstrumentParties *) x));
}
static void *_p_FIX__NoInstrumentPartiesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoInstrumentParties *) x));
}
static void *_p_FIX__LongQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LongQty *) x));
}
static void *_p_FIX__LegSwapTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegSwapType *) x));
}
static void *_p_FIX__FillQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::FillQty *) x));
}
static void *_p_FIX__InstrAttribValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::InstrAttribValue *) x));
}
static void *_p_FIX__DerivativeInstrAttribValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeInstrAttribValue *) x));
}
static void *_p_FIX__NestedInstrAttribValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NestedInstrAttribValue *) x));
}
static void *_p_FIX__RoundingModulusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RoundingModulus *) x));
}
static void *_p_FIX__AllocLinkTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocLinkType *) x));
}
static void *_p_FIX__AllocReportTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocReportType *) x));
}
static void *_p_FIX__TradeReportTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradeReportType *) x));
}
static void *_p_FIX__ResponseTransportTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ResponseTransportType *) x));
}
static void *_p_FIX__EncryptedPasswordTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncryptedPassword *) x));
}
static void *_p_FIX__PasswordTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Password *) x));
}
static void *_p_FIX__NewPasswordTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NewPassword *) x));
}
static void *_p_FIX__EncryptedNewPasswordTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncryptedNewPassword *) x));
}
static void *_p_FIX__ApplReportTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplReportType *) x));
}
static void *_p_FIX__PartyRelationshipTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PartyRelationship *) x));
}
static void *_p_FIX__UnderlyingSettlementTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingSettlementType *) x));
}
static void *_p_FIX__EventTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EventType *) x));
}
static void *_p_FIX__ComplexEventTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ComplexEventType *) x));
}
static void *_p_FIX__AllocAccountTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocAccountType *) x));
}
static void *_p_FIX__AccountTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AccountType *) x));
}
static void *_p_FIX__AdjustmentTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AdjustmentType *) x));
}
static void *_p_FIX__DerivativeEventTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeEventType *) x));
}
static void *_p_FIX__RespondentTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RespondentType *) x));
}
static void *_p_FIX__FutSettDate2To_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::FutSettDate2 *) x));
}
static void *_p_FIX__PriceDeltaTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PriceDelta *) x));
}
static void *_p_FIX__SideValue1To_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SideValue1 *) x));
}
static void *_p_FIX__SideValue2To_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SideValue2 *) x));
}
static void *_p_FIX__UnderlyingSymbolTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSymbol *) x));
}
static void *_p_FIX__RiskSymbolTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskSymbol *) x));
}
static void *_p_FIX__UnderlyingLegSymbolTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSymbol *) x));
}
static void *_p_FIX__PegSymbolTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PegSymbol *) x));
}
static void *_p_FIX__LegSymbolTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSymbol *) x));
}
static void *_p_FIX__DerivativeSymbolTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSymbol *) x));
}
static void *_p_FIX__RelationshipRiskSymbolTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskSymbol *) x));
}
static void *_p_FIX__OrderQty2To_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OrderQty2 *) x));
}
static void *_p_FIX__AltMDSourceIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AltMDSourceID *) x));
}
static void *_p_FIX__TotNoQuoteEntriesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoQuoteEntries *) x));
}
static void *_p_FIX__NoMDEntriesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoMDEntries *) x));
}
static void *_p_FIX__TotQuoteEntriesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotQuoteEntries *) x));
}
static void *_p_FIX__NoQuoteEntriesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoQuoteEntries *) x));
}
static void *_p_FIX__VenueTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::VenueType *) x));
}
static void *_p_FIX__TriggerNewQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TriggerNewQty *) x));
}
static void *_p_FIX__SideTimeInForceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::SideTimeInForce *) x));
}
static void *_p_FIX__TimeInForceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TimeInForce *) x));
}
static void *_p_FIX__SettlInstMsgIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlInstMsgID *) x));
}
static void *_p_FIX__AdvSideTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::AdvSide *) x));
}
static void *_p_FIX__SettlDate2To_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlDate2 *) x));
}
static void *_p_FIX__OrigOrdModTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::OrigOrdModTime *) x));
}
static void *_p_FIX__ApplQueueDepthTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplQueueDepth *) x));
}
static void *_p_FIX__MatchAlgorithmTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MatchAlgorithm *) x));
}
static void *_p_FIX__PartyAltSubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PartyAltSubID *) x));
}
static void *_p_FIX__RelatedPartyAltSubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelatedPartyAltSubID *) x));
}
static void *_p_FIX__SignatureTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Signature *) x));
}
static void *_p_FIX__LegInterestAccrualDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegInterestAccrualDate *) x));
}
static void *_p_FIX__InterestAccrualDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::InterestAccrualDate *) x));
}
static void *_p_FIX__SendingDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SendingDate *) x));
}
static void *_p_FIX__RegistIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RegistID *) x));
}
static void *_p_FIX__NewSeqNoTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NewSeqNo *) x));
}
static void *_p_FIX__LegInstrRegistryTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegInstrRegistry *) x));
}
static void *_p_FIX__InstrRegistryTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::InstrRegistry *) x));
}
static void *_p_FIX__NoMaturityRulesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoMaturityRules *) x));
}
static void *_p_FIX__DerivativeInstrRegistryTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeInstrRegistry *) x));
}
static void *_p_FIX__UnderlyingInstrRegistryTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingInstrRegistry *) x));
}
static void *_p_FIX__MiscFeeTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MiscFeeType *) x));
}
static void *_p_FIX__DeliveryDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DeliveryDate *) x));
}
static void *_p_FIX__ValidUntilTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::ValidUntilTime *) x));
}
static void *_p_FIX__QuoteSetValidUntilTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::QuoteSetValidUntilTime *) x));
}
static void *_p_FIX__ClientBidIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ClientBidID *) x));
}
static void *_p_FIX__RiskInstrumentOperatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RiskInstrumentOperator *) x));
}
static void *_p_FIX__RelationshipRiskInstrumentOperatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RelationshipRiskInstrumentOperator *) x));
}
static void *_p_FIX__EncodedSecurityListDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedSecurityListDesc *) x));
}
static void *_p_FIX__SecurityListDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityListDesc *) x));
}
static void *_p_FIX__ParentMktSegmIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ParentMktSegmID *) x));
}
static void *_p_FIX__StatsTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StatsType *) x));
}
static void *_p_FIX__NoComplexEventDatesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoComplexEventDates *) x));
}
static void *_p_FIX__LiquidityPctHighTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LiquidityPctHigh *) x));
}
static void *_p_FIX__SideReasonCdTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SideReasonCd *) x));
}
static void *_p_FIX__EncodedSymbolTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedSymbol *) x));
}
static void *_p_FIX__SymbolTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Symbol *) x));
}
static void *_p_FIX__NoPartyRelationshipsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoPartyRelationships *) x));
}
static void *_p_FIX__TriggerSymbolTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TriggerSymbol *) x));
}
static void *_p_FIX__NoSidesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSides *) x));
}
static void *_p_FIX__MDEntryTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeOnlyField *) ((FIX::MDEntryTime *) x));
}
static void *_p_FIX__ReportToExchTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ReportToExch *) x));
}
static void *_p_FIX__EncodedSubjectTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedSubject *) x));
}
static void *_p_FIX__SubjectTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Subject *) x));
}
static void *_p_FIX__AllocLinkIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocLinkID *) x));
}
static void *_p_FIX__TradeLinkIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeLinkID *) x));
}
static void *_p_FIX__LegBidPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegBidPx *) x));
}
static void *_p_FIX__NoLotTypeRulesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoLotTypeRules *) x));
}
static void *_p_FIX__ApplQueueMaxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplQueueMax *) x));
}
static void *_p_FIX__NoOrdTypeRulesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoOrdTypeRules *) x));
}
static void *_p_FIX__FundRenewWaivTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::FundRenewWaiv *) x));
}
static void *_p_FIX__AdjustmentTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::Adjustment *) x));
}
static void *_p_FIX__ExecPriceAdjustmentTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ExecPriceAdjustment *) x));
}
static void *_p_FIX__TargetSubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TargetSubID *) x));
}
static void *_p_FIX__ComplexEventPriceTimeTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ComplexEventPriceTimeType *) x));
}
static void *_p_FIX__LegOfferPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegOfferPx *) x));
}
static void *_p_FIX__MktOfferPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MktOfferPx *) x));
}
static void *_p_FIX__OfferPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OfferPx *) x));
}
static void *_p_FIX__LegPoolTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegPool *) x));
}
static void *_p_FIX__NoMDFeedTypesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoMDFeedTypes *) x));
}
static void *_p_FIX__LastSpotRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LastSpotRate *) x));
}
static void *_p_FIX__OfferSpotRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OfferSpotRate *) x));
}
static void *_p_FIX__BidSpotRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BidSpotRate *) x));
}
static void *_p_FIX__MDEntrySpotRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MDEntrySpotRate *) x));
}
static void *_p_FIX__DerivativeSecurityXMLSchemaTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityXMLSchema *) x));
}
static void *_p_FIX__SecurityXMLSchemaTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityXMLSchema *) x));
}
static void *_p_FIX__SettlInstCodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlInstCode *) x));
}
static void *_p_FIX__OpenInterestTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OpenInterest *) x));
}
static void *_p_FIX__NumDaysInterestTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NumDaysInterest *) x));
}
static void *_p_FIX__SideValueIndTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SideValueInd *) x));
}
static void *_p_FIX__UnderlyingLegMaturityMonthYearTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegMaturityMonthYear *) x));
}
static void *_p_FIX__UnderlyingMaturityMonthYearTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingMaturityMonthYear *) x));
}
static void *_p_FIX__EndMaturityMonthYearTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EndMaturityMonthYear *) x));
}
static void *_p_FIX__DerivativeMaturityMonthYearTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeMaturityMonthYear *) x));
}
static void *_p_FIX__MaturityMonthYearTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MaturityMonthYear *) x));
}
static void *_p_FIX__StartMaturityMonthYearTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StartMaturityMonthYear *) x));
}
static void *_p_FIX__LegMaturityMonthYearTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegMaturityMonthYear *) x));
}
static void *_p_FIX__RelationshipRiskMaturityMonthYearTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskMaturityMonthYear *) x));
}
static void *_p_FIX__RiskMaturityMonthYearTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskMaturityMonthYear *) x));
}
static void *_p_FIX__NoQuoteQualifiersTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoQuoteQualifiers *) x));
}
static void *_p_FIX__NoIOIQualifiersTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoIOIQualifiers *) x));
}
static void *_p_FIX__MDOriginTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDOriginType *) x));
}
static void *_p_FIX__DayOrderQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DayOrderQty *) x));
}
static void *_p_FIX__CashOrderQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CashOrderQty *) x));
}
static void *_p_FIX__LegOrderQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegOrderQty *) x));
}
static void *_p_FIX__OrderQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OrderQty *) x));
}
static void *_p_FIX__OrderInputDeviceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrderInputDevice *) x));
}
static void *_p_FIX__TradeInputDeviceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeInputDevice *) x));
}
static void *_p_FIX__RoutingIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RoutingID *) x));
}
static void *_p_FIX__NoPartyListTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoPartyList *) x));
}
static void *_p_FIX__TotNoPartyListTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoPartyList *) x));
}
static void *_p_FIX__NoSettlObligTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSettlOblig *) x));
}
static void *_p_FIX__NoDerivativeSecurityAltIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoDerivativeSecurityAltID *) x));
}
static void *_p_FIX__UnderlyingLegSecurityAltIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSecurityAltID *) x));
}
static void *_p_FIX__PartyAltIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PartyAltID *) x));
}
static void *_p_FIX__NoSecurityAltIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSecurityAltID *) x));
}
static void *_p_FIX__RelatedPartyAltIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelatedPartyAltID *) x));
}
static void *_p_FIX__RelationshipRiskSecurityAltIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskSecurityAltID *) x));
}
static void *_p_FIX__NoLegSecurityAltIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NoLegSecurityAltID *) x));
}
static void *_p_FIX__SecurityAltIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityAltID *) x));
}
static void *_p_FIX__LegSecurityAltIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSecurityAltID *) x));
}
static void *_p_FIX__NoUnderlyingSecurityAltIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoUnderlyingSecurityAltID *) x));
}
static void *_p_FIX__DerivativeSecurityAltIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityAltID *) x));
}
static void *_p_FIX__UnderlyingSecurityAltIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSecurityAltID *) x));
}
static void *_p_FIX__NoRelationshipRiskSecurityAltIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRelationshipRiskSecurityAltID *) x));
}
static void *_p_FIX__NoUnderlyingLegSecurityAltIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoUnderlyingLegSecurityAltID *) x));
}
static void *_p_FIX__NoRiskSecurityAltIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRiskSecurityAltID *) x));
}
static void *_p_FIX__RiskSecurityAltIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskSecurityAltID *) x));
}
static void *_p_FIX__HopSendingTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::HopSendingTime *) x));
}
static void *_p_FIX__OrigSendingTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::OrigSendingTime *) x));
}
static void *_p_FIX__OnBehalfOfSendingTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::OnBehalfOfSendingTime *) x));
}
static void *_p_FIX__SendingTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::SendingTime *) x));
}
static void *_p_FIX__ExecInstTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExecInst *) x));
}
static void *_p_FIX__EncodedListExecInstTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedListExecInst *) x));
}
static void *_p_FIX__LegExecInstTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegExecInst *) x));
}
static void *_p_FIX__ListExecInstTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ListExecInst *) x));
}
static void *_p_FIX__NoLinesOfTextTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoLinesOfText *) x));
}
static void *_p_FIX__LinesOfTextTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LinesOfText *) x));
}
static void *_p_FIX__SettlDepositoryCodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlDepositoryCode *) x));
}
static void *_p_FIX__TradedFlatSwitchTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::TradedFlatSwitch *) x));
}
static void *_p_FIX__ClOrdLinkIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ClOrdLinkID *) x));
}
static void *_p_FIX__NoStrikeRulesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoStrikeRules *) x));
}
static void *_p_FIX__NoTimeInForceRulesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoTimeInForceRules *) x));
}
static void *_p_FIX__IOIidTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::IOIid *) x));
}
static void *_p_FIX__LegBenchmarkPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegBenchmarkPrice *) x));
}
static void *_p_FIX__BenchmarkPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BenchmarkPrice *) x));
}
static void *_p_FIX__DueToRelatedTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::DueToRelated *) x));
}
static void *_p_FIX__DlvyInstTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DlvyInst *) x));
}
static void *_p_FIX__NoDlvyInstTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoDlvyInst *) x));
}
static void *_p_FIX__SecureDataTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecureData *) x));
}
static void *_p_FIX__AccruedInterestRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AccruedInterestRate *) x));
}
static void *_p_FIX__MDMktTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDMkt *) x));
}
static void *_p_FIX__MessageEncodingTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MessageEncoding *) x));
}
static void *_p_FIX__ExpireDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExpireDate *) x));
}
static void *_p_FIX__BasisFeatureDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BasisFeatureDate *) x));
}
static void *_p_FIX__DisplayWhenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DisplayWhen *) x));
}
static void *_p_FIX__EndTickPriceRangeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::EndTickPriceRange *) x));
}
static void *_p_FIX__StartTickPriceRangeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StartTickPriceRange *) x));
}
static void *_p_FIX__NoCompIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoCompIDs *) x));
}
static void *_p_FIX__BookingRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BookingRefID *) x));
}
static void *_p_FIX__WtAverageLiquidityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::WtAverageLiquidity *) x));
}
static void *_p_FIX__PriceImprovementTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PriceImprovement *) x));
}
static void *_p_FIX__SideTrdSubTypTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SideTrdSubTyp *) x));
}
static void *_p_FIX__MinPriceIncrementTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MinPriceIncrement *) x));
}
static void *_p_FIX__DerivativeMinPriceIncrementTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeMinPriceIncrement *) x));
}
static void *_p_FIX__StrikeIncrementTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StrikeIncrement *) x));
}
static void *_p_FIX__MatchIncrementTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MatchIncrement *) x));
}
static void *_p_FIX__MaturityMonthYearIncrementTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MaturityMonthYearIncrement *) x));
}
static void *_p_FIX__TickIncrementTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TickIncrement *) x));
}
static void *_p_FIX__ExecTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ExecType *) x));
}
static void *_p_FIX__MailingDtlsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MailingDtls *) x));
}
static void *_p_FIX__HaltReasonCharTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::HaltReasonChar *) x));
}
static void *_p_FIX__ModelTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ModelType *) x));
}
static void *_p_FIX__EventTextTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EventText *) x));
}
static void *_p_FIX__DerivativeEventTextTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeEventText *) x));
}
static void *_p_FIX__SettlInstReqRejCodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SettlInstReqRejCode *) x));
}
static void *_p_FIX__TriggerNewPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TriggerNewPrice *) x));
}
static void *_p_FIX__AllocRejCodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocRejCode *) x));
}
static void *_p_FIX__IndividualAllocRejCodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::IndividualAllocRejCode *) x));
}
static void *_p_FIX__ClearingFirmTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ClearingFirm *) x));
}
static void *_p_FIX__SettlementCycleNoTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SettlementCycleNo *) x));
}
static void *_p_FIX__TransactTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::TransactTime *) x));
}
static void *_p_FIX__TZTransactTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TZTransactTime *) x));
}
static void *_p_FIX__RelSymTransactTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::RelSymTransactTime *) x));
}
static void *_p_FIX__UnderlyingPriceUnitOfMeasureQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingPriceUnitOfMeasureQty *) x));
}
static void *_p_FIX__DerivativePriceUnitOfMeasureQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativePriceUnitOfMeasureQty *) x));
}
static void *_p_FIX__DerivativeUnitOfMeasureQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeUnitOfMeasureQty *) x));
}
static void *_p_FIX__UnderlyingUnitOfMeasureQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingUnitOfMeasureQty *) x));
}
static void *_p_FIX__UnitOfMeasureQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnitOfMeasureQty *) x));
}
static void *_p_FIX__LegPriceUnitOfMeasureQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegPriceUnitOfMeasureQty *) x));
}
static void *_p_FIX__PriceUnitOfMeasureQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PriceUnitOfMeasureQty *) x));
}
static void *_p_FIX__LegUnitOfMeasureQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegUnitOfMeasureQty *) x));
}
static void *_p_FIX__NewsRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NewsRefID *) x));
}
static void *_p_FIX__MDEntryTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MDEntryType *) x));
}
static void *_p_FIX__AvgParPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AvgParPx *) x));
}
static void *_p_FIX__IOIQltyIndTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::IOIQltyInd *) x));
}
static void *_p_FIX__TotNoAllocsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoAllocs *) x));
}
static void *_p_FIX__NoLegAllocsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoLegAllocs *) x));
}
static void *_p_FIX__NoAllocsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoAllocs *) x));
}
static void *_p_FIX__RegistDtlsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RegistDtls *) x));
}
static void *_p_FIX__NoRegistDtlsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRegistDtls *) x));
}
static void *_p_FIX__GTBookingInstTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::GTBookingInst *) x));
}
static void *_p_FIX__CustOrderHandlingInstTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CustOrderHandlingInst *) x));
}
static void *_p_FIX__MailingInstTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MailingInst *) x));
}
static void *_p_FIX__DayBookingInstTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DayBookingInst *) x));
}
static void *_p_FIX__DeskOrderHandlingInstTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DeskOrderHandlingInst *) x));
}
static void *_p_FIX__LegPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegPrice *) x));
}
static void *_p_FIX__RefApplVerIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefApplVerID *) x));
}
static void *_p_FIX__CstmApplVerIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CstmApplVerID *) x));
}
static void *_p_FIX__DefaultApplVerIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DefaultApplVerID *) x));
}
static void *_p_FIX__RefCstmApplVerIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefCstmApplVerID *) x));
}
static void *_p_FIX__ApplVerIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ApplVerID *) x));
}
static void *_p_FIX__DefaultCstmApplVerIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DefaultCstmApplVerID *) x));
}
static void *_p_FIX__LastMsgSeqNumProcessedTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LastMsgSeqNumProcessed *) x));
}
static void *_p_FIX__DateOfBirthTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DateOfBirth *) x));
}
static void *_p_FIX__SettlObligRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlObligRefID *) x));
}
static void *_p_FIX__LegRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegRefID *) x));
}
static void *_p_FIX__ContraLegRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ContraLegRefID *) x));
}
static void *_p_FIX__TradeLegRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeLegRefID *) x));
}
static void *_p_FIX__NoRateSourcesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRateSources *) x));
}
static void *_p_FIX__NotionalPercentageOutstandingTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::NotionalPercentageOutstanding *) x));
}
static void *_p_FIX__CashOutstandingTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CashOutstanding *) x));
}
static void *_p_FIX__UnderlyingNotionalPercentageOutstandingTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingNotionalPercentageOutstanding *) x));
}
static void *_p_FIX__TrdMatchIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TrdMatchID *) x));
}
static void *_p_FIX__OriginalNotionalPercentageOutstandingTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OriginalNotionalPercentageOutstanding *) x));
}
static void *_p_FIX__DeliverToCompIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DeliverToCompID *) x));
}
static void *_p_FIX__AllocPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllocPrice *) x));
}
static void *_p_FIX__StringFieldTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *)  ((FIX::StringField *) x));
}
static void *_p_FIX__DlvyInstTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DlvyInstType *) x));
}
static void *_p_FIX__ListExecInstTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ListExecInstType *) x));
}
static void *_p_FIX__AllocSettlInstTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocSettlInstType *) x));
}
static void *_p_FIX__TriggerTradingSessionIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TriggerTradingSessionID *) x));
}
static void *_p_FIX__TradingSessionIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradingSessionID *) x));
}
static void *_p_FIX__UnderlyingTradingSessionIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingTradingSessionID *) x));
}
static void *_p_FIX__PegScopeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PegScope *) x));
}
static void *_p_FIX__TotNoAccQuotesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoAccQuotes *) x));
}
static void *_p_FIX__CollInquiryIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CollInquiryID *) x));
}
static void *_p_FIX__ExecRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExecRefID *) x));
}
static void *_p_FIX__CxlRejResponseToTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::CxlRejResponseTo *) x));
}
static void *_p_FIX__LotTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::LotType *) x));
}
static void *_p_FIX__SideTrdRegTimestampSrcTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SideTrdRegTimestampSrc *) x));
}
static void *_p_FIX__EmailTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::EmailType *) x));
}
static void *_p_FIX__DerivativeOptAttributeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DerivativeOptAttribute *) x));
}
static void *_p_FIX__UnderlyingLegOptAttributeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::UnderlyingLegOptAttribute *) x));
}
static void *_p_FIX__UnderlyingOptAttributeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::UnderlyingOptAttribute *) x));
}
static void *_p_FIX__OptAttributeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::OptAttribute *) x));
}
static void *_p_FIX__LegOptAttributeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::LegOptAttribute *) x));
}
static void *_p_FIX__SettlLocationTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlLocation *) x));
}
static void *_p_FIX__EffectiveTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::EffectiveTime *) x));
}
static void *_p_FIX__StreamAsgnReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StreamAsgnReqID *) x));
}
static void *_p_FIX__AsgnReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AsgnReqID *) x));
}
static void *_p_FIX__QuoteCancelTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteCancelType *) x));
}
static void *_p_FIX__ExpireTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::ExpireTime *) x));
}
static void *_p_FIX__SettlBrkrCodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlBrkrCode *) x));
}
static void *_p_FIX__PreTradeAnonymityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::PreTradeAnonymity *) x));
}
static void *_p_FIX__RelationshipRiskRestructuringTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskRestructuringType *) x));
}
static void *_p_FIX__RestructuringTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RestructuringType *) x));
}
static void *_p_FIX__RoutingTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RoutingType *) x));
}
static void *_p_FIX__RiskRestructuringTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskRestructuringType *) x));
}
static void *_p_FIX__MultiLegReportingTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MultiLegReportingType *) x));
}
static void *_p_FIX__SideMultiLegReportingTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SideMultiLegReportingType *) x));
}
static void *_p_FIX__UnderlyingRestructuringTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingRestructuringType *) x));
}
static void *_p_FIX__BookingTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::BookingType *) x));
}
static void *_p_FIX__StatusValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StatusValue *) x));
}
static void *_p_FIX__AllowableOneSidednessValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllowableOneSidednessValue *) x));
}
static void *_p_FIX__NoTrdRegTimestampsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoTrdRegTimestamps *) x));
}
static void *_p_FIX__SecurityListIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityListID *) x));
}
static void *_p_FIX__DeliveryTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DeliveryType *) x));
}
static void *_p_FIX__SettlDeliveryTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SettlDeliveryType *) x));
}
static void *_p_FIX__PrivateQuoteTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::PrivateQuote *) x));
}
static void *_p_FIX__EncodedHeadlineLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedHeadlineLen *) x));
}
static void *_p_FIX__BasisPxTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::BasisPxType *) x));
}
static void *_p_FIX__StrikeRuleIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StrikeRuleID *) x));
}
static void *_p_FIX__MaturityRuleIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MaturityRuleID *) x));
}
static void *_p_FIX__QuoteMsgIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuoteMsgID *) x));
}
static void *_p_FIX__DeskTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DeskType *) x));
}
static void *_p_FIX__CardHolderNameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CardHolderName *) x));
}
static void *_p_FIX__StrategyParameterNameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StrategyParameterName *) x));
}
static void *_p_FIX__RndPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RndPx *) x));
}
static void *_p_FIX__TotNoSecurityTypesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoSecurityTypes *) x));
}
static void *_p_FIX__TotalNumSecurityTypesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotalNumSecurityTypes *) x));
}
static void *_p_FIX__NoMDEntryTypesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoMDEntryTypes *) x));
}
static void *_p_FIX__NoRiskWarningLevelsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRiskWarningLevels *) x));
}
static void *_p_FIX__NoRelationshipRiskWarningLevelsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRelationshipRiskWarningLevels *) x));
}
static void *_p_FIX__MaxPriceLevelsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MaxPriceLevels *) x));
}
static void *_p_FIX__NoSecurityTypesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSecurityTypes *) x));
}
static void *_p_FIX__OnBehalfOfCompIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OnBehalfOfCompID *) x));
}
static void *_p_FIX__HopCompIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::HopCompID *) x));
}
static void *_p_FIX__TargetCompIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TargetCompID *) x));
}
static void *_p_FIX__SenderCompIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SenderCompID *) x));
}
static void *_p_FIX__RefCompIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefCompID *) x));
}
static void *_p_FIX__ListStatusTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ListStatusType *) x));
}
static void *_p_FIX__MDBookTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDBookType *) x));
}
static void *_p_FIX__MDSubBookTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDSubBookType *) x));
}
static void *_p_FIX__DerivativeSecurityListRequestTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeSecurityListRequestType *) x));
}
static void *_p_FIX__MassCancelRequestTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MassCancelRequestType *) x));
}
static void *_p_FIX__SecurityRequestTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityRequestType *) x));
}
static void *_p_FIX__SubscriptionRequestTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SubscriptionRequestType *) x));
}
static void *_p_FIX__SecurityListRequestTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityListRequestType *) x));
}
static void *_p_FIX__QuoteRequestTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteRequestType *) x));
}
static void *_p_FIX__SecurityListTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityListType *) x));
}
static void *_p_FIX__TradeRequestTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradeRequestType *) x));
}
static void *_p_FIX__UserRequestTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UserRequestType *) x));
}
static void *_p_FIX__NetworkRequestTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NetworkRequestType *) x));
}
static void *_p_FIX__EncodedIssuerLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedIssuerLen *) x));
}
static void *_p_FIX__EncodedLegIssuerLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedLegIssuerLen *) x));
}
static void *_p_FIX__DerivativeEncodedIssuerLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeEncodedIssuerLen *) x));
}
static void *_p_FIX__EncodedUnderlyingIssuerLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedUnderlyingIssuerLen *) x));
}
static void *_p_FIX__TotNoRejQuotesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoRejQuotes *) x));
}
static void *_p_FIX__TotNoCxldQuotesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoCxldQuotes *) x));
}
static void *_p_FIX__ProductComplexTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ProductComplex *) x));
}
static void *_p_FIX__RelationshipRiskProductComplexTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskProductComplex *) x));
}
static void *_p_FIX__RiskProductComplexTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskProductComplex *) x));
}
static void *_p_FIX__DerivativeProductComplexTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeProductComplex *) x));
}
static void *_p_FIX__TextTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Text *) x));
}
static void *_p_FIX__CustOrderCapacityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CustOrderCapacity *) x));
}
static void *_p_FIX__OrigCustOrderCapacityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::OrigCustOrderCapacity *) x));
}
static void *_p_FIX__OrderCapacityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::OrderCapacity *) x));
}
static void *_p_FIX__DealingCapacityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DealingCapacity *) x));
}
static void *_p_FIX__AllocCustomerCapacityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocCustomerCapacity *) x));
}
static void *_p_FIX__LastCapacityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::LastCapacity *) x));
}
static void *_p_FIX__PoolTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Pool *) x));
}
static void *_p_FIX__LiquidityNumSecuritiesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LiquidityNumSecurities *) x));
}
static void *_p_FIX__TotalNumSecuritiesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotalNumSecurities *) x));
}
static void *_p_FIX__RegistEmailTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RegistEmail *) x));
}
static void *_p_FIX__ComplianceIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ComplianceID *) x));
}
static void *_p_FIX__SideComplianceIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SideComplianceID *) x));
}
static void *_p_FIX__EndSeqNoTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EndSeqNo *) x));
}
static void *_p_FIX__PartySubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PartySubID *) x));
}
static void *_p_FIX__RootPartySubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RootPartySubID *) x));
}
static void *_p_FIX__Nested2PartySubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Nested2PartySubID *) x));
}
static void *_p_FIX__RelatedContextPartySubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelatedContextPartySubID *) x));
}
static void *_p_FIX__RelatedPartySubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelatedPartySubID *) x));
}
static void *_p_FIX__InstrumentPartySubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::InstrumentPartySubID *) x));
}
static void *_p_FIX__ContextPartySubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ContextPartySubID *) x));
}
static void *_p_FIX__NestedPartySubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NestedPartySubID *) x));
}
static void *_p_FIX__StreamAsgnAckTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StreamAsgnAckType *) x));
}
static void *_p_FIX__SettlPartySubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlPartySubID *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartySubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingInstrumentPartySubID *) x));
}
static void *_p_FIX__Nested4PartySubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Nested4PartySubID *) x));
}
static void *_p_FIX__Nested3PartySubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Nested3PartySubID *) x));
}
static void *_p_FIX__DerivativeInstrumentPartySubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeInstrumentPartySubID *) x));
}
static void *_p_FIX__UndlyInstrumentPartySubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UndlyInstrumentPartySubID *) x));
}
static void *_p_FIX__TrdRegTimestampOriginTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TrdRegTimestampOrigin *) x));
}
static void *_p_FIX__CashDistribPayRefTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashDistribPayRef *) x));
}
static void *_p_FIX__AdvIdTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AdvId *) x));
}
static void *_p_FIX__RegistAcctTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RegistAcctType *) x));
}
static void *_p_FIX__DistribPercentageTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DistribPercentage *) x));
}
static void *_p_FIX__ListIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ListID *) x));
}
static void *_p_FIX__NoMarketSegmentsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoMarketSegments *) x));
}
static void *_p_FIX__IOIOthSvcTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::IOIOthSvc *) x));
}
static void *_p_FIX__ExchangeRuleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExchangeRule *) x));
}
static void *_p_FIX__RefTagIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RefTagID *) x));
}
static void *_p_FIX__ReceivedDeptIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ReceivedDeptID *) x));
}
static void *_p_FIX__ProgRptReqsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ProgRptReqs *) x));
}
static void *_p_FIX__ListSeqNoTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ListSeqNo *) x));
}
static void *_p_FIX__MDStreamIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDStreamID *) x));
}
static void *_p_FIX__CustDirectedOrderTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::CustDirectedOrder *) x));
}
static void *_p_FIX__MDEntrySizeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MDEntrySize *) x));
}
static void *_p_FIX__TargetStrategyPerformanceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TargetStrategyPerformance *) x));
}
static void *_p_FIX__RptSysTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RptSys *) x));
}
static void *_p_FIX__LegQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegQty *) x));
}
static void *_p_FIX__EFPTrackingErrorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::EFPTrackingError *) x));
}
static void *_p_FIX__MktBidPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MktBidPx *) x));
}
static void *_p_FIX__StreamAsgnRptIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StreamAsgnRptID *) x));
}
static void *_p_FIX__AsgnRptIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AsgnRptID *) x));
}
static void *_p_FIX__MaxFloorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MaxFloor *) x));
}
static void *_p_FIX__AllocInterestAtMaturityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllocInterestAtMaturity *) x));
}
static void *_p_FIX__InterestAtMaturityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::InterestAtMaturity *) x));
}
static void *_p_FIX__SecondaryExecIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryExecID *) x));
}
static void *_p_FIX__SideExecIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SideExecID *) x));
}
static void *_p_FIX__MDSecSizeTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDSecSizeType *) x));
}
static void *_p_FIX__CustomerOrFirmTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CustomerOrFirm *) x));
}
static void *_p_FIX__EncodedUnderlyingSecurityDescLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedUnderlyingSecurityDescLen *) x));
}
static void *_p_FIX__RelationshipRiskEncodedSecurityDescLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RelationshipRiskEncodedSecurityDescLen *) x));
}
static void *_p_FIX__DerivativeEncodedSecurityDescLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeEncodedSecurityDescLen *) x));
}
static void *_p_FIX__EncodedMktSegmDescLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedMktSegmDescLen *) x));
}
static void *_p_FIX__EncodedLegSecurityDescLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedLegSecurityDescLen *) x));
}
static void *_p_FIX__EncodedSecurityListDescLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedSecurityListDescLen *) x));
}
static void *_p_FIX__EncodedSecurityDescLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedSecurityDescLen *) x));
}
static void *_p_FIX__RiskEncodedSecurityDescLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RiskEncodedSecurityDescLen *) x));
}
static void *_p_FIX__MDEntryOriginatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDEntryOriginator *) x));
}
static void *_p_FIX__FutSettDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::FutSettDate *) x));
}
static void *_p_FIX__LegFutSettDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegFutSettDate *) x));
}
static void *_p_FIX__BidDescriptorTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::BidDescriptorType *) x));
}
static void *_p_FIX__NoMiscFeesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoMiscFees *) x));
}
static void *_p_FIX__PegMoveTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PegMoveType *) x));
}
static void *_p_FIX__DiscretionMoveTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DiscretionMoveType *) x));
}
static void *_p_FIX__ClientIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ClientID *) x));
}
static void *_p_FIX__RawDataLengthTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RawDataLength *) x));
}
static void *_p_FIX__BodyLengthTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::BodyLength *) x));
}
static void *_p_FIX__SignatureLengthTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SignatureLength *) x));
}
static void *_p_FIX__NoClearingInstructionsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoClearingInstructions *) x));
}
static void *_p_FIX__OrderRestrictionsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrderRestrictions *) x));
}
static void *_p_FIX__ExchangeSpecialInstructionsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExchangeSpecialInstructions *) x));
}
static void *_p_FIX__MDEntrySellerTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDEntrySeller *) x));
}
static void *_p_FIX__MinLotSizeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MinLotSize *) x));
}
static void *_p_FIX__MDSecSizeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MDSecSize *) x));
}
static void *_p_FIX__MaturityDayTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MaturityDay *) x));
}
static void *_p_FIX__MassActionResponseTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MassActionResponse *) x));
}
static void *_p_FIX__MassCancelResponseTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MassCancelResponse *) x));
}
static void *_p_FIX__UnderlyingMaturityDayTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingMaturityDay *) x));
}
static void *_p_FIX__SideFillStationCdTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SideFillStationCd *) x));
}
static void *_p_FIX__IOISharesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::IOIShares *) x));
}
static void *_p_FIX__NoPartyListResponseTypesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoPartyListResponseTypes *) x));
}
static void *_p_FIX__AllocSharesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllocShares *) x));
}
static void *_p_FIX__PartyIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PartyID *) x));
}
static void *_p_FIX__Nested4PartyIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Nested4PartyID *) x));
}
static void *_p_FIX__ContextPartyIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ContextPartyID *) x));
}
static void *_p_FIX__SettlPartyIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlPartyID *) x));
}
static void *_p_FIX__RelatedPartyIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelatedPartyID *) x));
}
static void *_p_FIX__NestedPartyIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NestedPartyID *) x));
}
static void *_p_FIX__Nested3PartyIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Nested3PartyID *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartyIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingInstrumentPartyID *) x));
}
static void *_p_FIX__RelatedContextPartyIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelatedContextPartyID *) x));
}
static void *_p_FIX__TargetPartyIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TargetPartyID *) x));
}
static void *_p_FIX__UndlyInstrumentPartyIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UndlyInstrumentPartyID *) x));
}
static void *_p_FIX__RootPartyIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RootPartyID *) x));
}
static void *_p_FIX__DerivativeInstrumentPartyIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeInstrumentPartyID *) x));
}
static void *_p_FIX__InstrumentPartyIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::InstrumentPartyID *) x));
}
static void *_p_FIX__Nested2PartyIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Nested2PartyID *) x));
}
static void *_p_FIX__CcyAmtTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CcyAmt *) x));
}
static void *_p_FIX__ApplQueueResolutionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplQueueResolution *) x));
}
static void *_p_FIX__DayAvgPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DayAvgPx *) x));
}
static void *_p_FIX__NoHopsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoHops *) x));
}
static void *_p_FIX__IOIIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::IOIID *) x));
}
static void *_p_FIX__SecurityXMLLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityXMLLen *) x));
}
static void *_p_FIX__DerivativeSecurityXMLLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeSecurityXMLLen *) x));
}
static void *_p_FIX__NoRoutingIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRoutingIDs *) x));
}
static void *_p_FIX__MDEntryIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDEntryID *) x));
}
static void *_p_FIX__QuoteEntryIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuoteEntryID *) x));
}
static void *_p_FIX__FillExecIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::FillExecID *) x));
}
static void *_p_FIX__ExecIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExecID *) x));
}
static void *_p_FIX__InvestorCountryOfResidenceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::InvestorCountryOfResidence *) x));
}
static void *_p_FIX__SpreadTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Spread *) x));
}
static void *_p_FIX__RefreshIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::RefreshIndicator *) x));
}
static void *_p_FIX__DefaultVerIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::DefaultVerIndicator *) x));
}
static void *_p_FIX__TradeAllocIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradeAllocIndicator *) x));
}
static void *_p_FIX__RiskFlexibleIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::RiskFlexibleIndicator *) x));
}
static void *_p_FIX__TrdRepIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::TrdRepIndicator *) x));
}
static void *_p_FIX__PublishTrdIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::PublishTrdIndicator *) x));
}
static void *_p_FIX__TradePublishIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradePublishIndicator *) x));
}
static void *_p_FIX__CopyMsgIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::CopyMsgIndicator *) x));
}
static void *_p_FIX__AllocClearingFeeIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocClearingFeeIndicator *) x));
}
static void *_p_FIX__ImpliedMarketIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ImpliedMarketIndicator *) x));
}
static void *_p_FIX__UnsolicitedIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::UnsolicitedIndicator *) x));
}
static void *_p_FIX__LateIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::LateIndicator *) x));
}
static void *_p_FIX__FlexibleIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::FlexibleIndicator *) x));
}
static void *_p_FIX__ClearingFeeIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ClearingFeeIndicator *) x));
}
static void *_p_FIX__AutoAcceptIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::AutoAcceptIndicator *) x));
}
static void *_p_FIX__RelationshipRiskFlexibleIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::RelationshipRiskFlexibleIndicator *) x));
}
static void *_p_FIX__AsOfIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::AsOfIndicator *) x));
}
static void *_p_FIX__DerivFlexProductEligibilityIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::DerivFlexProductEligibilityIndicator *) x));
}
static void *_p_FIX__AvgPxIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AvgPxIndicator *) x));
}
static void *_p_FIX__TestMessageIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::TestMessageIndicator *) x));
}
static void *_p_FIX__WorkingIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::WorkingIndicator *) x));
}
static void *_p_FIX__NoTradingSessionRulesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoTradingSessionRules *) x));
}
static void *_p_FIX__PriorSpreadIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::PriorSpreadIndicator *) x));
}
static void *_p_FIX__ManualOrderIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ManualOrderIndicator *) x));
}
static void *_p_FIX__ContraryInstructionIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ContraryInstructionIndicator *) x));
}
static void *_p_FIX__ReversalIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ReversalIndicator *) x));
}
static void *_p_FIX__PriorityIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PriorityIndicator *) x));
}
static void *_p_FIX__FlexProductEligibilityIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::FlexProductEligibilityIndicator *) x));
}
static void *_p_FIX__AggressorIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::AggressorIndicator *) x));
}
static void *_p_FIX__MarketSegmentIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MarketSegmentID *) x));
}
static void *_p_FIX__ComplexEventPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ComplexEventPrice *) x));
}
static void *_p_FIX__AgreementIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AgreementID *) x));
}
static void *_p_FIX__ContraBrokerTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ContraBroker *) x));
}
static void *_p_FIX__ExecBrokerTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExecBroker *) x));
}
static void *_p_FIX__SettlCurrFxRateCalcTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlCurrFxRateCalc *) x));
}
static void *_p_FIX__UnderlyingFXRateCalcTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::UnderlyingFXRateCalc *) x));
}
static void *_p_FIX__ExDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExDate *) x));
}
static void *_p_FIX__PosMaintRptRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PosMaintRptRefID *) x));
}
static void *_p_FIX__TradeReportRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeReportRefID *) x));
}
static void *_p_FIX__AllocReportRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocReportRefID *) x));
}
static void *_p_FIX__SecondaryTradeReportRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryTradeReportRefID *) x));
}
static void *_p_FIX__Price2To_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Price2 *) x));
}
static void *_p_FIX__ExpirationCycleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ExpirationCycle *) x));
}
static void *_p_FIX__ResetSeqNumFlagTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ResetSeqNumFlag *) x));
}
static void *_p_FIX__YieldTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Yield *) x));
}
static void *_p_FIX__UnderlyingSettlPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingSettlPrice *) x));
}
static void *_p_FIX__SettlPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SettlPrice *) x));
}
static void *_p_FIX__PriorSettlPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PriorSettlPrice *) x));
}
static void *_p_FIX__SideLiquidityIndTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SideLiquidityInd *) x));
}
static void *_p_FIX__LastLiquidityIndTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LastLiquidityInd *) x));
}
static void *_p_FIX__FillLiquidityIndTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::FillLiquidityInd *) x));
}
static void *_p_FIX__EncodedUnderlyingIssuerTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedUnderlyingIssuer *) x));
}
static void *_p_FIX__DerivativeIssuerTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeIssuer *) x));
}
static void *_p_FIX__EncodedLegIssuerTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedLegIssuer *) x));
}
static void *_p_FIX__UnderlyingIssuerTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingIssuer *) x));
}
static void *_p_FIX__LegIssuerTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegIssuer *) x));
}
static void *_p_FIX__TradingSessionDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradingSessionDesc *) x));
}
static void *_p_FIX__MassStatusReqTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MassStatusReqType *) x));
}
static void *_p_FIX__PosReqTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PosReqType *) x));
}
static void *_p_FIX__StreamAsgnReqTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StreamAsgnReqType *) x));
}
static void *_p_FIX__AllocIntermedReqTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocIntermedReqType *) x));
}
static void *_p_FIX__ApplReqTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplReqType *) x));
}
static void *_p_FIX__LastSharesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LastShares *) x));
}
static void *_p_FIX__UnderlyingFXRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingFXRate *) x));
}
static void *_p_FIX__SharesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Shares *) x));
}
static void *_p_FIX__UnderlyingLegSecurityExchangeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSecurityExchange *) x));
}
static void *_p_FIX__UnderlyingSecurityExchangeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSecurityExchange *) x));
}
static void *_p_FIX__RiskSecurityExchangeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskSecurityExchange *) x));
}
static void *_p_FIX__LegSecurityExchangeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSecurityExchange *) x));
}
static void *_p_FIX__SecurityExchangeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityExchange *) x));
}
static void *_p_FIX__RelationshipRiskSecurityExchangeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskSecurityExchange *) x));
}
static void *_p_FIX__DerivativeSecurityExchangeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityExchange *) x));
}
static void *_p_FIX__YieldTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::YieldType *) x));
}
static void *_p_FIX__CardIssNoTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CardIssNo *) x));
}
static void *_p_FIX__UnderlyingEndPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingEndPrice *) x));
}
static void *_p_FIX__AllocQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllocQty *) x));
}
static void *_p_FIX__LegAllocQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegAllocQty *) x));
}
static void *_p_FIX__ConfirmIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ConfirmID *) x));
}
static void *_p_FIX__PartySubIDTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PartySubIDType *) x));
}
static void *_p_FIX__InstrumentPartySubIDTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::InstrumentPartySubIDType *) x));
}
static void *_p_FIX__RootPartySubIDTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RootPartySubIDType *) x));
}
static void *_p_FIX__DerivativeInstrumentPartySubIDTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeInstrumentPartySubIDType *) x));
}
static void *_p_FIX__Nested2PartySubIDTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::Nested2PartySubIDType *) x));
}
static void *_p_FIX__UndlyInstrumentPartySubIDTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UndlyInstrumentPartySubIDType *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartySubIDTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingInstrumentPartySubIDType *) x));
}
static void *_p_FIX__SettlPartySubIDTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SettlPartySubIDType *) x));
}
static void *_p_FIX__RelatedPartyAltSubIDTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RelatedPartyAltSubIDType *) x));
}
static void *_p_FIX__Nested3PartySubIDTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::Nested3PartySubIDType *) x));
}
static void *_p_FIX__NestedPartySubIDTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NestedPartySubIDType *) x));
}
static void *_p_FIX__Nested4PartySubIDTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::Nested4PartySubIDType *) x));
}
static void *_p_FIX__PartyAltSubIDTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PartyAltSubIDType *) x));
}
static void *_p_FIX__RelatedPartySubIDTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RelatedPartySubIDType *) x));
}
static void *_p_FIX__SolicitedFlagTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::SolicitedFlag *) x));
}
static void *_p_FIX__ContextPartySubIDTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ContextPartySubIDType *) x));
}
static void *_p_FIX__RelatedContextPartySubIDTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RelatedContextPartySubIDType *) x));
}
static void *_p_FIX__MiscFeeAmtTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MiscFeeAmt *) x));
}
static void *_p_FIX__UnderlyingRedemptionDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingRedemptionDate *) x));
}
static void *_p_FIX__RedemptionDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RedemptionDate *) x));
}
static void *_p_FIX__TradeOriginationDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeOriginationDate *) x));
}
static void *_p_FIX__LegRedemptionDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegRedemptionDate *) x));
}
static void *_p_FIX__YieldRedemptionDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::YieldRedemptionDate *) x));
}
static void *_p_FIX__UserStatusTextTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UserStatusText *) x));
}
static void *_p_FIX__StatusTextTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StatusText *) x));
}
static void *_p_FIX__ListStatusTextTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ListStatusText *) x));
}
static void *_p_FIX__EncodedListStatusTextTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedListStatusText *) x));
}
static void *_p_FIX__OutsideIndexPctTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OutsideIndexPct *) x));
}
static void *_p_FIX__NoPosAmtTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoPosAmt *) x));
}
static void *_p_FIX__HeadlineTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Headline *) x));
}
static void *_p_FIX__EncodedHeadlineTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedHeadline *) x));
}
static void *_p_FIX__AttachmentPointTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AttachmentPoint *) x));
}
static void *_p_FIX__DetachmentPointTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DetachmentPoint *) x));
}
static void *_p_FIX__UnderlyingAttachmentPointTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingAttachmentPoint *) x));
}
static void *_p_FIX__UnderlyingDetachmentPointTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingDetachmentPoint *) x));
}
static void *_p_FIX__DatedDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DatedDate *) x));
}
static void *_p_FIX__TotalVolumeTradedDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcDateField *) ((FIX::TotalVolumeTradedDate *) x));
}
static void *_p_FIX__LegDatedDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegDatedDate *) x));
}
static void *_p_FIX__LegIOIQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegIOIQty *) x));
}
static void *_p_FIX__LastRptRequestedTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::LastRptRequested *) x));
}
static void *_p_FIX__UnderlyingCouponRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingCouponRate *) x));
}
static void *_p_FIX__RiskCouponRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RiskCouponRate *) x));
}
static void *_p_FIX__RelationshipRiskCouponRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RelationshipRiskCouponRate *) x));
}
static void *_p_FIX__ApplIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ApplID *) x));
}
static void *_p_FIX__RefApplIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefApplID *) x));
}
static void *_p_FIX__CouponRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CouponRate *) x));
}
static void *_p_FIX__LegCouponRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegCouponRate *) x));
}
static void *_p_FIX__NoSideTrdRegTSTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSideTrdRegTS *) x));
}
static void *_p_FIX__LowLimitPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LowLimitPrice *) x));
}
static void *_p_FIX__SecondaryLowLimitPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SecondaryLowLimitPrice *) x));
}
static void *_p_FIX__HighLimitPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::HighLimitPrice *) x));
}
static void *_p_FIX__SecondaryHighLimitPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SecondaryHighLimitPrice *) x));
}
static void *_p_FIX__UnderlyingStartValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingStartValue *) x));
}
static void *_p_FIX__UnderlyingCurrentValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingCurrentValue *) x));
}
static void *_p_FIX__NoApplIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoApplIDs *) x));
}
static void *_p_FIX__SecuritySettlAgentNameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecuritySettlAgentName *) x));
}
static void *_p_FIX__CashDistribAgentNameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashDistribAgentName *) x));
}
static void *_p_FIX__CashSettlAgentNameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashSettlAgentName *) x));
}
static void *_p_FIX__BusinessRejectRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BusinessRejectRefID *) x));
}
static void *_p_FIX__SettlInstRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlInstRefID *) x));
}
static void *_p_FIX__SecurityListRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityListRefID *) x));
}
static void *_p_FIX__RegistRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RegistRefID *) x));
}
static void *_p_FIX__DerivativeCapPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeCapPrice *) x));
}
static void *_p_FIX__CapPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CapPrice *) x));
}
static void *_p_FIX__IntFieldTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *)  ((FIX::IntField *) x));
}
static void *_p_FIX__CashSettlAgentContactPhoneTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashSettlAgentContactPhone *) x));
}
static void *_p_FIX__SecuritySettlAgentContactPhoneTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecuritySettlAgentContactPhone *) x));
}
static void *_p_FIX__RoundLotTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RoundLot *) x));
}
static void *_p_FIX__RejectTextTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RejectText *) x));
}
static void *_p_FIX__HopRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::HopRefID *) x));
}
static void *_p_FIX__ExerciseStyleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ExerciseStyle *) x));
}
static void *_p_FIX__StrikeExerciseStyleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StrikeExerciseStyle *) x));
}
static void *_p_FIX__NoStrikesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoStrikes *) x));
}
static void *_p_FIX__LegExerciseStyleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegExerciseStyle *) x));
}
static void *_p_FIX__TotNoStrikesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoStrikes *) x));
}
static void *_p_FIX__DerivativeExerciseStyleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DerivativeExerciseStyle *) x));
}
static void *_p_FIX__UnderlyingExerciseStyleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingExerciseStyle *) x));
}
static void *_p_FIX__NoAsgnReqsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoAsgnReqs *) x));
}
static void *_p_FIX__IssuerTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Issuer *) x));
}
static void *_p_FIX__DerivativeEncodedIssuerTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeEncodedIssuer *) x));
}
static void *_p_FIX__EncodedIssuerTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedIssuer *) x));
}
static void *_p_FIX__FillPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::FillPx *) x));
}
static void *_p_FIX__CheckSumTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CheckSumField *) ((FIX::CheckSum *) x));
}
static void *_p_FIX__OfferYieldTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OfferYield *) x));
}
static void *_p_FIX__PeggedPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PeggedPrice *) x));
}
static void *_p_FIX__UnderlyingEndValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingEndValue *) x));
}
static void *_p_FIX__DeliverToLocationIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DeliverToLocationID *) x));
}
static void *_p_FIX__SenderLocationIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SenderLocationID *) x));
}
static void *_p_FIX__TargetLocationIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TargetLocationID *) x));
}
static void *_p_FIX__LocationIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LocationID *) x));
}
static void *_p_FIX__OnBehalfOfLocationIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OnBehalfOfLocationID *) x));
}
static void *_p_FIX__URLLinkTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::URLLink *) x));
}
static void *_p_FIX__CashDistribCurrTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashDistribCurr *) x));
}
static void *_p_FIX__ContingencyTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ContingencyType *) x));
}
static void *_p_FIX__PosReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PosReqID *) x));
}
static void *_p_FIX__TradSesReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradSesReqID *) x));
}
static void *_p_FIX__MassStatusReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MassStatusReqID *) x));
}
static void *_p_FIX__OrdStatusReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrdStatusReqID *) x));
}
static void *_p_FIX__QuoteStatusReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuoteStatusReqID *) x));
}
static void *_p_FIX__SecurityStatusReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityStatusReqID *) x));
}
static void *_p_FIX__TotalTakedownTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TotalTakedown *) x));
}
static void *_p_FIX__PosAmtTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PosAmt *) x));
}
static void *_p_FIX__ProgPeriodIntervalTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ProgPeriodInterval *) x));
}
static void *_p_FIX__UnderlyingRepurchaseRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingRepurchaseRate *) x));
}
static void *_p_FIX__RepurchaseRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RepurchaseRate *) x));
}
static void *_p_FIX__LegRepurchaseRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegRepurchaseRate *) x));
}
static void *_p_FIX__LastParPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LastParPx *) x));
}
static void *_p_FIX__BeginStringTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BeginString *) x));
}
static void *_p_FIX__NoDistribInstsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoDistribInsts *) x));
}
static void *_p_FIX__LiquidityPctLowTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LiquidityPctLow *) x));
}
static void *_p_FIX__CardIssNumTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CardIssNum *) x));
}
static void *_p_FIX__MsgTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MsgType *) x));
}
static void *_p_FIX__RefMsgTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefMsgType *) x));
}
static void *_p_FIX__TotNoFillsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoFills *) x));
}
static void *_p_FIX__NoFillsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoFills *) x));
}
static void *_p_FIX__TradSesPreCloseTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::TradSesPreCloseTime *) x));
}
static void *_p_FIX__TradSesCloseTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::TradSesCloseTime *) x));
}
static void *_p_FIX__IOIQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::IOIQty *) x));
}
static void *_p_FIX__DisplayHighQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DisplayHighQty *) x));
}
static void *_p_FIX__BidDescriptorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BidDescriptor *) x));
}
static void *_p_FIX__ParticipationRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ParticipationRate *) x));
}
static void *_p_FIX__CollAsgnRespTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollAsgnRespType *) x));
}
static void *_p_FIX__QuoteRespTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteRespType *) x));
}
static void *_p_FIX__TradeVolumeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TradeVolume *) x));
}
static void *_p_FIX__BuyVolumeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BuyVolume *) x));
}
static void *_p_FIX__TotalNetValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TotalNetValue *) x));
}
static void *_p_FIX__DiscretionOffsetValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DiscretionOffsetValue *) x));
}
static void *_p_FIX__ExecInstValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ExecInstValue *) x));
}
static void *_p_FIX__ContAmtValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ContAmtValue *) x));
}
static void *_p_FIX__PegOffsetValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PegOffsetValue *) x));
}
static void *_p_FIX__NoPartyAltIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoPartyAltIDs *) x));
}
static void *_p_FIX__NoRelatedPartyAltIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRelatedPartyAltIDs *) x));
}
static void *_p_FIX__StrikeTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::StrikeTime *) x));
}
static void *_p_FIX__HeartBtIntTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::HeartBtInt *) x));
}
static void *_p_FIX__UnderlyingStipValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingStipValue *) x));
}
static void *_p_FIX__UnderlyingCapValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingCapValue *) x));
}
static void *_p_FIX__EncryptedPasswordLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncryptedPasswordLen *) x));
}
static void *_p_FIX__EncryptedNewPasswordLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncryptedNewPasswordLen *) x));
}
static void *_p_FIX__RelationshipRiskInstrumentMultiplierTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RelationshipRiskInstrumentMultiplier *) x));
}
static void *_p_FIX__FeeMultiplierTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::FeeMultiplier *) x));
}
static void *_p_FIX__RiskInstrumentMultiplierTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RiskInstrumentMultiplier *) x));
}
static void *_p_FIX__ContractMultiplierTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ContractMultiplier *) x));
}
static void *_p_FIX__LegContractMultiplierTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegContractMultiplier *) x));
}
static void *_p_FIX__UnderlyingContractMultiplierTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingContractMultiplier *) x));
}
static void *_p_FIX__StrikeMultiplierTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StrikeMultiplier *) x));
}
static void *_p_FIX__DerivativeContractMultiplierTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeContractMultiplier *) x));
}
static void *_p_FIX__DerivativeStrikeMultiplierTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeStrikeMultiplier *) x));
}
static void *_p_FIX__RegistRejReasonCodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RegistRejReasonCode *) x));
}
static void *_p_FIX__ForexReqTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ForexReq *) x));
}
static void *_p_FIX__SettlSessIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlSessID *) x));
}
static void *_p_FIX__UtcTimeStampFieldTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *)  ((FIX::UtcTimeStampField *) x));
}
static void *_p_FIX__OddLotTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::OddLot *) x));
}
static void *_p_FIX__LanguageCodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LanguageCode *) x));
}
static void *_p_FIX__NewsRefTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NewsRefType *) x));
}
static void *_p_FIX__EncodedSubjectLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedSubjectLen *) x));
}
static void *_p_FIX__TotalVolumeTradedTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeOnlyField *) ((FIX::TotalVolumeTradedTime *) x));
}
static void *_p_FIX__TotalVolumeTradedTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TotalVolumeTraded *) x));
}
static void *_p_FIX__NoContraBrokersTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoContraBrokers *) x));
}
static void *_p_FIX__OutMainCntryUIndexTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OutMainCntryUIndex *) x));
}
static void *_p_FIX__BoolFieldTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *)  ((FIX::BoolField *) x));
}
static void *_p_FIX__UnderlyingPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingPx *) x));
}
static void *_p_FIX__ContraTraderTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ContraTrader *) x));
}
static void *_p_FIX__NoTradesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoTrades *) x));
}
static void *_p_FIX__AllowableOneSidednessPctTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllowableOneSidednessPct *) x));
}
static void *_p_FIX__NextExpectedMsgSeqNumTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NextExpectedMsgSeqNum *) x));
}
static void *_p_FIX__ApplNewSeqNumTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplNewSeqNum *) x));
}
static void *_p_FIX__LegVolatilityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegVolatility *) x));
}
static void *_p_FIX__VolatilityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Volatility *) x));
}
static void *_p_FIX__MsgSeqNumTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MsgSeqNum *) x));
}
static void *_p_FIX__ApplBegSeqNumTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplBegSeqNum *) x));
}
static void *_p_FIX__NoNewsRefIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNewsRefIDs *) x));
}
static void *_p_FIX__ContAmtCurrTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ContAmtCurr *) x));
}
static void *_p_FIX__StandInstDbTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StandInstDbType *) x));
}
static void *_p_FIX__ClearingInstructionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ClearingInstruction *) x));
}
static void *_p_FIX__LastMktTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LastMkt *) x));
}
static void *_p_FIX__SecurityResponseTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityResponseType *) x));
}
static void *_p_FIX__ApplResponseTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplResponseType *) x));
}
static void *_p_FIX__PartyListResponseTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PartyListResponseType *) x));
}
static void *_p_FIX__NetworkStatusResponseTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NetworkStatusResponseType *) x));
}
static void *_p_FIX__SecondaryAllocIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryAllocID *) x));
}
static void *_p_FIX__IndividualAllocIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::IndividualAllocID *) x));
}
static void *_p_FIX__RefAllocIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefAllocID *) x));
}
static void *_p_FIX__AllocIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocID *) x));
}
static void *_p_FIX__SecondaryIndividualAllocIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryIndividualAllocID *) x));
}
static void *_p_FIX__LegAllocIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegAllocID *) x));
}
static void *_p_FIX__LegIndividualAllocIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegIndividualAllocID *) x));
}
static void *_p_FIX__EmailThreadIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EmailThreadID *) x));
}
static void *_p_FIX__SellVolumeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SellVolume *) x));
}
static void *_p_FIX__RelationshipRiskEncodedSecurityDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskEncodedSecurityDesc *) x));
}
static void *_p_FIX__LegSecurityDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSecurityDesc *) x));
}
static void *_p_FIX__DerivativeEncodedSecurityDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeEncodedSecurityDesc *) x));
}
static void *_p_FIX__DerivativeSecurityDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityDesc *) x));
}
static void *_p_FIX__TriggerSecurityDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TriggerSecurityDesc *) x));
}
static void *_p_FIX__EncodedUnderlyingSecurityDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedUnderlyingSecurityDesc *) x));
}
static void *_p_FIX__RiskEncodedSecurityDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskEncodedSecurityDesc *) x));
}
static void *_p_FIX__SecurityDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityDesc *) x));
}
static void *_p_FIX__UnderlyingSecurityDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSecurityDesc *) x));
}
static void *_p_FIX__EncodedLegSecurityDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedLegSecurityDesc *) x));
}
static void *_p_FIX__EncodedSecurityDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedSecurityDesc *) x));
}
static void *_p_FIX__RelationshipRiskSecurityDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskSecurityDesc *) x));
}
static void *_p_FIX__UnderlyingLegSecurityDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSecurityDesc *) x));
}
static void *_p_FIX__PegSecurityDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PegSecurityDesc *) x));
}
static void *_p_FIX__RiskSecurityDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskSecurityDesc *) x));
}
static void *_p_FIX__NoComplexEventTimesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoComplexEventTimes *) x));
}
static void *_p_FIX__CardExpDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CardExpDate *) x));
}
static void *_p_FIX__EncodedSymbolLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedSymbolLen *) x));
}
static void *_p_FIX__AllocAccruedInterestAmtTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllocAccruedInterestAmt *) x));
}
static void *_p_FIX__AccruedInterestAmtTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AccruedInterestAmt *) x));
}
static void *_p_FIX__TotalAccruedInterestAmtTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TotalAccruedInterestAmt *) x));
}
static void *_p_FIX__EndAccruedInterestAmtTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::EndAccruedInterestAmt *) x));
}
static void *_p_FIX__UnderlyingContractMultiplierUnitTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingContractMultiplierUnit *) x));
}
static void *_p_FIX__ContractMultiplierUnitTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ContractMultiplierUnit *) x));
}
static void *_p_FIX__LegContractMultiplierUnitTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegContractMultiplierUnit *) x));
}
static void *_p_FIX__DerivativeContractMultiplierUnitTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeContractMultiplierUnit *) x));
}
static void *_p_FIX__LegSideTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::LegSide *) x));
}
static void *_p_FIX__BidIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BidID *) x));
}
static void *_p_FIX__TargetStrategyParametersTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TargetStrategyParameters *) x));
}
static void *_p_FIX__NoStrategyParametersTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoStrategyParameters *) x));
}
static void *_p_FIX__NoCapacitiesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoCapacities *) x));
}
static void *_p_FIX__NoRiskLimitsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRiskLimits *) x));
}
static void *_p_FIX__NoRelationshipRiskLimitsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRelationshipRiskLimits *) x));
}
static void *_p_FIX__LegMaturityDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegMaturityDate *) x));
}
static void *_p_FIX__DerivativeMaturityDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeMaturityDate *) x));
}
static void *_p_FIX__QuantityDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuantityDate *) x));
}
static void *_p_FIX__UnderlyingLegMaturityDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegMaturityDate *) x));
}
static void *_p_FIX__MaturityDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MaturityDate *) x));
}
static void *_p_FIX__UnderlyingMaturityDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingMaturityDate *) x));
}
static void *_p_FIX__MsgDirectionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MsgDirection *) x));
}
static void *_p_FIX__PegRoundDirectionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PegRoundDirection *) x));
}
static void *_p_FIX__RoundingDirectionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::RoundingDirection *) x));
}
static void *_p_FIX__TriggerPriceDirectionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TriggerPriceDirection *) x));
}
static void *_p_FIX__TickDirectionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TickDirection *) x));
}
static void *_p_FIX__DiscretionRoundDirectionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DiscretionRoundDirection *) x));
}
static void *_p_FIX__WaveNoTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::WaveNo *) x));
}
static void *_p_FIX__HighPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::HighPx *) x));
}
static void *_p_FIX__PossResendTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::PossResend *) x));
}
static void *_p_FIX__AvgPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AvgPx *) x));
}
static void *_p_FIX__RateSourceTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RateSourceType *) x));
}
static void *_p_FIX__SecurityGroupTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityGroup *) x));
}
static void *_p_FIX__RelationshipRiskSecurityGroupTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskSecurityGroup *) x));
}
static void *_p_FIX__RiskSecurityGroupTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskSecurityGroup *) x));
}
static void *_p_FIX__DerivativeSecurityGroupTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityGroup *) x));
}
static void *_p_FIX__TotNoOrdersTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoOrders *) x));
}
static void *_p_FIX__NoOrdersTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoOrders *) x));
}
static void *_p_FIX__PosReqResultTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PosReqResult *) x));
}
static void *_p_FIX__CollInquiryResultTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollInquiryResult *) x));
}
static void *_p_FIX__PegDifferenceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PegDifference *) x));
}
static void *_p_FIX__MDUpdateActionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MDUpdateAction *) x));
}
static void *_p_FIX__MarketUpdateActionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MarketUpdateAction *) x));
}
static void *_p_FIX__ApplQueueActionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplQueueAction *) x));
}
static void *_p_FIX__SecurityUpdateActionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SecurityUpdateAction *) x));
}
static void *_p_FIX__ListUpdateActionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ListUpdateAction *) x));
}
static void *_p_FIX__TradSesUpdateActionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TradSesUpdateAction *) x));
}
static void *_p_FIX__CorporateActionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CorporateAction *) x));
}
static void *_p_FIX__NewsIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NewsID *) x));
}
static void *_p_FIX__PreviouslyReportedTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::PreviouslyReported *) x));
}
static void *_p_FIX__MaxTradeVolTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MaxTradeVol *) x));
}
static void *_p_FIX__MinTradeVolTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MinTradeVol *) x));
}
static void *_p_FIX__DiscretionInstTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DiscretionInst *) x));
}
static void *_p_FIX__AllowableOneSidednessCurrTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllowableOneSidednessCurr *) x));
}
static void *_p_FIX__AllocNoOrdersTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocNoOrdersType *) x));
}
static void *_p_FIX__ConfirmStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ConfirmStatus *) x));
}
static void *_p_FIX__QuoteStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteStatus *) x));
}
static void *_p_FIX__SecurityStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityStatus *) x));
}
static void *_p_FIX__QuoteEntryStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteEntryStatus *) x));
}
static void *_p_FIX__AffirmStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AffirmStatus *) x));
}
static void *_p_FIX__TradSesStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradSesStatus *) x));
}
static void *_p_FIX__QuoteAckStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteAckStatus *) x));
}
static void *_p_FIX__PosQtyStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PosQtyStatus *) x));
}
static void *_p_FIX__CollInquiryStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollInquiryStatus *) x));
}
static void *_p_FIX__SecurityTradingStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityTradingStatus *) x));
}
static void *_p_FIX__AllocStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocStatus *) x));
}
static void *_p_FIX__PosReqStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PosReqStatus *) x));
}
static void *_p_FIX__MoneyLaunderingStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MoneyLaunderingStatus *) x));
}
static void *_p_FIX__DerivativeSecurityStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityStatus *) x));
}
static void *_p_FIX__ExecAckStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ExecAckStatus *) x));
}
static void *_p_FIX__ApplEndSeqNumTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplEndSeqNum *) x));
}
static void *_p_FIX__RefApplLastSeqNumTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RefApplLastSeqNum *) x));
}
static void *_p_FIX__ApplSeqNumTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplSeqNum *) x));
}
static void *_p_FIX__ApplLastSeqNumTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplLastSeqNum *) x));
}
static void *_p_FIX__RefSeqNumTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RefSeqNum *) x));
}
static void *_p_FIX__OrderBookingQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OrderBookingQty *) x));
}
static void *_p_FIX__UnderlyingQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingQty *) x));
}
static void *_p_FIX__CPProgramTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CPProgram *) x));
}
static void *_p_FIX__UnderlyingCPProgramTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingCPProgram *) x));
}
static void *_p_FIX__MDEntryPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MDEntryPx *) x));
}
static void *_p_FIX__ConfirmTransTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ConfirmTransType *) x));
}
static void *_p_FIX__IOITransTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::IOITransType *) x));
}
static void *_p_FIX__AllocTransTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::AllocTransType *) x));
}
static void *_p_FIX__AdvTransTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AdvTransType *) x));
}
static void *_p_FIX__CollAsgnTransTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollAsgnTransType *) x));
}
static void *_p_FIX__TradeReportTransTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradeReportTransType *) x));
}
static void *_p_FIX__RegistTransTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::RegistTransType *) x));
}
static void *_p_FIX__SettlInstTransTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlInstTransType *) x));
}
static void *_p_FIX__BidRequestTransTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::BidRequestTransType *) x));
}
static void *_p_FIX__ExecTransTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ExecTransType *) x));
}
static void *_p_FIX__SettlObligTransTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlObligTransType *) x));
}
static void *_p_FIX__PosTransTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PosTransType *) x));
}
static void *_p_FIX__BidForwardPoints2To_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BidForwardPoints2 *) x));
}
static void *_p_FIX__OfferForwardPoints2To_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OfferForwardPoints2 *) x));
}
static void *_p_FIX__LastForwardPoints2To_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LastForwardPoints2 *) x));
}
static void *_p_FIX__CollAsgnIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CollAsgnID *) x));
}
static void *_p_FIX__OpenCloseTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::OpenClose *) x));
}
static void *_p_FIX__RiskWarningLevelNameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskWarningLevelName *) x));
}
static void *_p_FIX__RelationshipRiskWarningLevelNameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskWarningLevelName *) x));
}
static void *_p_FIX__AllocPositionEffectTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::AllocPositionEffect *) x));
}
static void *_p_FIX__LegPositionEffectTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::LegPositionEffect *) x));
}
static void *_p_FIX__PositionEffectTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::PositionEffect *) x));
}
static void *_p_FIX__NoUndlyInstrumentPartySubIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoUndlyInstrumentPartySubIDs *) x));
}
static void *_p_FIX__NoRelatedContextPartySubIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRelatedContextPartySubIDs *) x));
}
static void *_p_FIX__NoNested2PartySubIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNested2PartySubIDs *) x));
}
static void *_p_FIX__NoPartySubIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoPartySubIDs *) x));
}
static void *_p_FIX__NoInstrumentPartySubIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoInstrumentPartySubIDs *) x));
}
static void *_p_FIX__NoContextPartySubIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoContextPartySubIDs *) x));
}
static void *_p_FIX__NoDerivativeInstrumentPartySubIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoDerivativeInstrumentPartySubIDs *) x));
}
static void *_p_FIX__NoSettlPartySubIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSettlPartySubIDs *) x));
}
static void *_p_FIX__NoNested3PartySubIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNested3PartySubIDs *) x));
}
static void *_p_FIX__NoNested4PartySubIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNested4PartySubIDs *) x));
}
static void *_p_FIX__NoNestedPartySubIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNestedPartySubIDs *) x));
}
static void *_p_FIX__NoRootPartySubIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRootPartySubIDs *) x));
}
static void *_p_FIX__NoRelatedPartySubIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRelatedPartySubIDs *) x));
}
static void *_p_FIX__IncTaxIndTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::IncTaxInd *) x));
}
static void *_p_FIX__RepurchaseTermTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RepurchaseTerm *) x));
}
static void *_p_FIX__UnderlyingRepurchaseTermTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingRepurchaseTerm *) x));
}
static void *_p_FIX__LegRepurchaseTermTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegRepurchaseTerm *) x));
}
static void *_p_FIX__RelatdSymTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelatdSym *) x));
}
static void *_p_FIX__OpenCloseSettleFlagTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OpenCloseSettleFlag *) x));
}
static void *_p_FIX__DefaultApplExtIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DefaultApplExtID *) x));
}
static void *_p_FIX__ApplExtIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplExtID *) x));
}
static void *_p_FIX__RegistDetlsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RegistDetls *) x));
}
static void *_p_FIX__RefApplExtIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RefApplExtID *) x));
}
static void *_p_FIX__NoRequestedPartyRolesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRequestedPartyRoles *) x));
}
static void *_p_FIX__SenderSubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SenderSubID *) x));
}
static void *_p_FIX__SettlObligModeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SettlObligMode *) x));
}
static void *_p_FIX__StipulationTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StipulationType *) x));
}
static void *_p_FIX__LegStipulationTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegStipulationType *) x));
}
static void *_p_FIX__MassActionTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MassActionType *) x));
}
static void *_p_FIX__TerminationTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TerminationType *) x));
}
static void *_p_FIX__SettlObligIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlObligID *) x));
}
static void *_p_FIX__OrigClOrdIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrigClOrdID *) x));
}
static void *_p_FIX__ClOrdIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ClOrdID *) x));
}
static void *_p_FIX__SecondaryClOrdIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryClOrdID *) x));
}
static void *_p_FIX__NotAffOrigClOrdIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NotAffOrigClOrdID *) x));
}
static void *_p_FIX__PaymentRemitterIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PaymentRemitterID *) x));
}
static void *_p_FIX__BidTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::BidType *) x));
}
static void *_p_FIX__UnderlyingTradingSessionSubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingTradingSessionSubID *) x));
}
static void *_p_FIX__TriggerTradingSessionSubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TriggerTradingSessionSubID *) x));
}
static void *_p_FIX__TradingSessionSubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradingSessionSubID *) x));
}
static void *_p_FIX__MarketIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MarketID *) x));
}
static void *_p_FIX__TaxAdvantageTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TaxAdvantageType *) x));
}
static void *_p_FIX__NoSettlDetailsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSettlDetails *) x));
}
static void *_p_FIX__DayCumQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DayCumQty *) x));
}
static void *_p_FIX__MDEntryPositionNoTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDEntryPositionNo *) x));
}
static void *_p_FIX__UnderlyingSettlPriceTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingSettlPriceType *) x));
}
static void *_p_FIX__TriggerPriceTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TriggerPriceType *) x));
}
static void *_p_FIX__LegBenchmarkPriceTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegBenchmarkPriceType *) x));
}
static void *_p_FIX__PegPriceTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PegPriceType *) x));
}
static void *_p_FIX__YieldRedemptionPriceTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::YieldRedemptionPriceType *) x));
}
static void *_p_FIX__QuotePriceTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuotePriceType *) x));
}
static void *_p_FIX__PriceTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PriceType *) x));
}
static void *_p_FIX__SettlPriceTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SettlPriceType *) x));
}
static void *_p_FIX__ExecPriceTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ExecPriceType *) x));
}
static void *_p_FIX__LegPriceTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegPriceType *) x));
}
static void *_p_FIX__BenchmarkPriceTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::BenchmarkPriceType *) x));
}
static void *_p_FIX__StreamAsgnTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StreamAsgnType *) x));
}
static void *_p_FIX__NumberOfOrdersTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NumberOfOrders *) x));
}
static void *_p_FIX__NoAffectedOrdersTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoAffectedOrders *) x));
}
static void *_p_FIX__TotalAffectedOrdersTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotalAffectedOrders *) x));
}
static void *_p_FIX__NoNotAffectedOrdersTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNotAffectedOrders *) x));
}
static void *_p_FIX__SecurityRequestResultTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityRequestResult *) x));
}
static void *_p_FIX__PosMaintResultTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PosMaintResult *) x));
}
static void *_p_FIX__TradeRequestResultTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradeRequestResult *) x));
}
static void *_p_FIX__PartyDetailsRequestResultTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PartyDetailsRequestResult *) x));
}
static void *_p_FIX__OrderDelayUnitTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::OrderDelayUnit *) x));
}
static void *_p_FIX__EndCashTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::EndCash *) x));
}
static void *_p_FIX__TriggerActionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TriggerAction *) x));
}
static void *_p_FIX__CollActionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollAction *) x));
}
static void *_p_FIX__PosMaintActionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PosMaintAction *) x));
}
static void *_p_FIX__RefSubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefSubID *) x));
}
static void *_p_FIX__OnBehalfOfSubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OnBehalfOfSubID *) x));
}
static void *_p_FIX__UnderlyingDirtyPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingDirtyPrice *) x));
}
static void *_p_FIX__OrderCapacityQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OrderCapacityQty *) x));
}
static void *_p_FIX__UnderlyingSecurityIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSecurityID *) x));
}
static void *_p_FIX__RiskSecurityIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskSecurityID *) x));
}
static void *_p_FIX__PegSecurityIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PegSecurityID *) x));
}
static void *_p_FIX__TriggerSecurityIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TriggerSecurityID *) x));
}
static void *_p_FIX__LegSecurityIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSecurityID *) x));
}
static void *_p_FIX__SecurityIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityID *) x));
}
static void *_p_FIX__DerivativeSecurityIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityID *) x));
}
static void *_p_FIX__BenchmarkSecurityIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BenchmarkSecurityID *) x));
}
static void *_p_FIX__UnderlyingLegSecurityIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSecurityID *) x));
}
static void *_p_FIX__RelationshipRiskSecurityIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskSecurityID *) x));
}
static void *_p_FIX__MatchStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MatchStatus *) x));
}
static void *_p_FIX__CollStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollStatus *) x));
}
static void *_p_FIX__FinancialStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::FinancialStatus *) x));
}
static void *_p_FIX__TrdRptStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TrdRptStatus *) x));
}
static void *_p_FIX__UserStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UserStatus *) x));
}
static void *_p_FIX__RegistStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::RegistStatus *) x));
}
static void *_p_FIX__ListOrderStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ListOrderStatus *) x));
}
static void *_p_FIX__TradeRequestStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradeRequestStatus *) x));
}
static void *_p_FIX__SessionStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SessionStatus *) x));
}
static void *_p_FIX__SecDefStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecDefStatus *) x));
}
static void *_p_FIX__UnderlyingSettlementStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSettlementStatus *) x));
}
static void *_p_FIX__OrdStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::OrdStatus *) x));
}
static void *_p_FIX__PosMaintStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PosMaintStatus *) x));
}
static void *_p_FIX__OrderAvgPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OrderAvgPx *) x));
}
static void *_p_FIX__MDEntryRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDEntryRefID *) x));
}
static void *_p_FIX__XmlDataLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::XmlDataLen *) x));
}
static void *_p_FIX__SecureDataLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecureDataLen *) x));
}
static void *_p_FIX__MultiLegRptTypeReqTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MultiLegRptTypeReq *) x));
}
static void *_p_FIX__MaturityTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MaturityTime *) x));
}
static void *_p_FIX__UnderlyingMaturityTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingMaturityTime *) x));
}
static void *_p_FIX__RiskMaturityTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskMaturityTime *) x));
}
static void *_p_FIX__DerivativeMaturityTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeMaturityTime *) x));
}
static void *_p_FIX__RelationshipRiskMaturityTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskMaturityTime *) x));
}
static void *_p_FIX__UnderlyingLegMaturityTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegMaturityTime *) x));
}
static void *_p_FIX__LegMaturityTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegMaturityTime *) x));
}
static void *_p_FIX__NoTickRulesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoTickRules *) x));
}
static void *_p_FIX__ClearingBusinessDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ClearingBusinessDate *) x));
}
static void *_p_FIX__PositionLimitTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PositionLimit *) x));
}
static void *_p_FIX__DerivativeNTPositionLimitTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeNTPositionLimit *) x));
}
static void *_p_FIX__NTPositionLimitTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NTPositionLimit *) x));
}
static void *_p_FIX__DerivativePositionLimitTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativePositionLimit *) x));
}
static void *_p_FIX__QuoteSetIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuoteSetID *) x));
}
static void *_p_FIX__QuantityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Quantity *) x));
}
static void *_p_FIX__UnderlyingAdjustedQuantityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingAdjustedQuantity *) x));
}
static void *_p_FIX__NoRelatedPartyAltSubIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRelatedPartyAltSubIDs *) x));
}
static void *_p_FIX__NoPartyAltSubIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoPartyAltSubIDs *) x));
}
static void *_p_FIX__DerivativeOptPayAmountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeOptPayAmount *) x));
}
static void *_p_FIX__UnderlyingDeliveryAmountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingDeliveryAmount *) x));
}
static void *_p_FIX__UnderlyingPayAmountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingPayAmount *) x));
}
static void *_p_FIX__OptPayAmountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OptPayAmount *) x));
}
static void *_p_FIX__ConfirmRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ConfirmRefID *) x));
}
static void *_p_FIX__RiskLimitPlatformTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskLimitPlatform *) x));
}
static void *_p_FIX__RelationshipRiskLimitPlatformTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskLimitPlatform *) x));
}
static void *_p_FIX__NoContAmtsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoContAmts *) x));
}
static void *_p_FIX__IndividualAllocTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::IndividualAllocType *) x));
}
static void *_p_FIX__AllocTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocType *) x));
}
static void *_p_FIX__SharedCommissionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SharedCommission *) x));
}
static void *_p_FIX__CommissionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Commission *) x));
}
static void *_p_FIX__UnderlyingOriginalNotionalPercentageOutstandingTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingOriginalNotionalPercentageOutstanding *) x));
}
static void *_p_FIX__DiscretionOffsetTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DiscretionOffset *) x));
}
static void *_p_FIX__MidPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MidPx *) x));
}
static void *_p_FIX__IOIRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::IOIRefID *) x));
}
static void *_p_FIX__BasisFeaturePriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BasisFeaturePrice *) x));
}
static void *_p_FIX__DerivativeProductTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeProduct *) x));
}
static void *_p_FIX__RelationshipRiskProductTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RelationshipRiskProduct *) x));
}
static void *_p_FIX__RiskProductTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RiskProduct *) x));
}
static void *_p_FIX__LegProductTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegProduct *) x));
}
static void *_p_FIX__UnderlyingProductTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingProduct *) x));
}
static void *_p_FIX__ProductTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::Product *) x));
}
static void *_p_FIX__LocateReqdTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::LocateReqd *) x));
}
static void *_p_FIX__ConcessionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Concession *) x));
}
static void *_p_FIX__CommTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::CommType *) x));
}
static void *_p_FIX__MaxPriceVariationTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MaxPriceVariation *) x));
}
static void *_p_FIX__CumQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CumQty *) x));
}
static void *_p_FIX__OrigTradeHandlingInstrTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::OrigTradeHandlingInstr *) x));
}
static void *_p_FIX__TradeHandlingInstrTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TradeHandlingInstr *) x));
}
static void *_p_FIX__MDFeedTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDFeedType *) x));
}
static void *_p_FIX__TriggerPriceTypeScopeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TriggerPriceTypeScope *) x));
}
static void *_p_FIX__NetChgPrevDayTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::NetChgPrevDay *) x));
}
static void *_p_FIX__TrdRegTimestampTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::TrdRegTimestamp *) x));
}
static void *_p_FIX__SideTrdRegTimestampTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::SideTrdRegTimestamp *) x));
}
static void *_p_FIX__AssignmentUnitTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AssignmentUnit *) x));
}
static void *_p_FIX__DisplayMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DisplayMethod *) x));
}
static void *_p_FIX__PriceQuoteMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PriceQuoteMethod *) x));
}
static void *_p_FIX__StrikePriceBoundaryMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StrikePriceBoundaryMethod *) x));
}
static void *_p_FIX__PreallocMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::PreallocMethod *) x));
}
static void *_p_FIX__AllocMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocMethod *) x));
}
static void *_p_FIX__ComplexEventPriceBoundaryMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ComplexEventPriceBoundaryMethod *) x));
}
static void *_p_FIX__MultilegPriceMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MultilegPriceMethod *) x));
}
static void *_p_FIX__DerivativePriceQuoteMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativePriceQuoteMethod *) x));
}
static void *_p_FIX__ExerciseMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ExerciseMethod *) x));
}
static void *_p_FIX__CollReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CollReqID *) x));
}
static void *_p_FIX__RefApplReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefApplReqID *) x));
}
static void *_p_FIX__ApplReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ApplReqID *) x));
}
static void *_p_FIX__TradSesMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradSesMethod *) x));
}
static void *_p_FIX__NoBidComponentsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoBidComponents *) x));
}
static void *_p_FIX__LiquidityValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LiquidityValue *) x));
}
static void *_p_FIX__OrigTradeDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrigTradeDate *) x));
}
static void *_p_FIX__TradeDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeDate *) x));
}
static void *_p_FIX__ListNameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ListName *) x));
}
static void *_p_FIX__PctAtRiskTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PctAtRisk *) x));
}
static void *_p_FIX__UtcTimeOnlyFieldTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *)  ((FIX::UtcTimeOnlyField *) x));
}
static void *_p_FIX__TotNoRelatedSymTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoRelatedSym *) x));
}
static void *_p_FIX__NoRelatedSymTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRelatedSym *) x));
}
static void *_p_FIX__MDReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDReqID *) x));
}
static void *_p_FIX__LegCurrencyRatioTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegCurrencyRatio *) x));
}
static void *_p_FIX__CurrencyRatioTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CurrencyRatio *) x));
}
static void *_p_FIX__AllocNetMoneyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllocNetMoney *) x));
}
static void *_p_FIX__NetMoneyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::NetMoney *) x));
}
static void *_p_FIX__MaturityNetMoneyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MaturityNetMoney *) x));
}
static void *_p_FIX__RatioQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RatioQty *) x));
}
static void *_p_FIX__LegRatioQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegRatioQty *) x));
}
static void *_p_FIX__LegBenchmarkCurveNameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegBenchmarkCurveName *) x));
}
static void *_p_FIX__OrigPosReqRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrigPosReqRefID *) x));
}
static void *_p_FIX__BenchmarkCurveNameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BenchmarkCurveName *) x));
}
static void *_p_FIX__AggregatedBookTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::AggregatedBook *) x));
}
static void *_p_FIX__LegBenchmarkCurvePointTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegBenchmarkCurvePoint *) x));
}
static void *_p_FIX__BenchmarkCurvePointTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BenchmarkCurvePoint *) x));
}
static void *_p_FIX__OptPayoutAmountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OptPayoutAmount *) x));
}
static void *_p_FIX__UnderlyingCollectAmountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingCollectAmount *) x));
}
static void *_p_FIX__ComplexOptPayoutAmountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ComplexOptPayoutAmount *) x));
}
static void *_p_FIX__RelationshipRiskLimitAmountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RelationshipRiskLimitAmount *) x));
}
static void *_p_FIX__ThresholdAmountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ThresholdAmount *) x));
}
static void *_p_FIX__DerivativeMinPriceIncrementAmountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeMinPriceIncrementAmount *) x));
}
static void *_p_FIX__RiskLimitAmountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RiskLimitAmount *) x));
}
static void *_p_FIX__UnderlyingCashAmountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingCashAmount *) x));
}
static void *_p_FIX__MinPriceIncrementAmountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MinPriceIncrementAmount *) x));
}
static void *_p_FIX__OpenCloseSettlFlagTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OpenCloseSettlFlag *) x));
}
static void *_p_FIX__ApplResendFlagTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ApplResendFlag *) x));
}
static void *_p_FIX__DisplayMinIncrTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DisplayMinIncr *) x));
}
static void *_p_FIX__MaxShowTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MaxShow *) x));
}
static void *_p_FIX__NoExecsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoExecs *) x));
}
static void *_p_FIX__SettlCurrFxRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SettlCurrFxRate *) x));
}
static void *_p_FIX__SettlCurrOfferFxRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SettlCurrOfferFxRate *) x));
}
static void *_p_FIX__SettlCurrBidFxRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SettlCurrBidFxRate *) x));
}
static void *_p_FIX__DeliveryFormTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DeliveryForm *) x));
}
static void *_p_FIX__HostCrossIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::HostCrossID *) x));
}
static void *_p_FIX__OrigCrossIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrigCrossID *) x));
}
static void *_p_FIX__CrossIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CrossID *) x));
}
static void *_p_FIX__TargetStrategyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TargetStrategy *) x));
}
static void *_p_FIX__SecuritySettlAgentContactNameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecuritySettlAgentContactName *) x));
}
static void *_p_FIX__SecuritySettlAgentAcctNameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecuritySettlAgentAcctName *) x));
}
static void *_p_FIX__CashDistribAgentAcctNameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashDistribAgentAcctName *) x));
}
static void *_p_FIX__CashSettlAgentAcctNameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashSettlAgentAcctName *) x));
}
static void *_p_FIX__NoPartyIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoPartyIDs *) x));
}
static void *_p_FIX__NoRootPartyIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRootPartyIDs *) x));
}
static void *_p_FIX__NoTargetPartyIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoTargetPartyIDs *) x));
}
static void *_p_FIX__NoNested4PartyIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNested4PartyIDs *) x));
}
static void *_p_FIX__NoContextPartyIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoContextPartyIDs *) x));
}
static void *_p_FIX__NoSettlPartyIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSettlPartyIDs *) x));
}
static void *_p_FIX__NoNestedPartyIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNestedPartyIDs *) x));
}
static void *_p_FIX__NoRelatedPartyIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRelatedPartyIDs *) x));
}
static void *_p_FIX__NoNested2PartyIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNested2PartyIDs *) x));
}
static void *_p_FIX__NoNested3PartyIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNested3PartyIDs *) x));
}
static void *_p_FIX__CashSettlAgentContactNameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashSettlAgentContactName *) x));
}
static void *_p_FIX__NoRelatedContextPartyIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRelatedContextPartyIDs *) x));
}
static void *_p_FIX__FirstPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::FirstPx *) x));
}
static void *_p_FIX__NoOfSecSizesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoOfSecSizes *) x));
}
static void *_p_FIX__UnderlyingLegStrikePriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingLegStrikePrice *) x));
}
static void *_p_FIX__LegStrikePriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegStrikePrice *) x));
}
static void *_p_FIX__DerivativeStrikePriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeStrikePrice *) x));
}
static void *_p_FIX__SecondaryTradingReferencePriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SecondaryTradingReferencePrice *) x));
}
static void *_p_FIX__UnderlyingStrikePriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingStrikePrice *) x));
}
static void *_p_FIX__StrikePriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StrikePrice *) x));
}
static void *_p_FIX__TradingReferencePriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TradingReferencePrice *) x));
}
static void *_p_FIX__AvgPrxPrecisionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AvgPrxPrecision *) x));
}
static void *_p_FIX__ComplexEventPriceBoundaryPrecisionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ComplexEventPriceBoundaryPrecision *) x));
}
static void *_p_FIX__StrikePriceBoundaryPrecisionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StrikePriceBoundaryPrecision *) x));
}
static void *_p_FIX__AvgPxPrecisionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AvgPxPrecision *) x));
}
static void *_p_FIX__MaturityMonthYearIncrementUnitsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MaturityMonthYearIncrementUnits *) x));
}
static void *_p_FIX__MDEntryBuyerTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDEntryBuyer *) x));
}
static void *_p_FIX__LegSettlDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSettlDate *) x));
}
static void *_p_FIX__SettlDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlDate *) x));
}
static void *_p_FIX__LeavesQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LeavesQty *) x));
}
static void *_p_FIX__ComplexEventEndDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::ComplexEventEndDate *) x));
}
static void *_p_FIX__EndDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EndDate *) x));
}
static void *_p_FIX__SettlInstReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlInstReqID *) x));
}
static void *_p_FIX__MarketReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MarketReqID *) x));
}
static void *_p_FIX__TestReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TestReqID *) x));
}
static void *_p_FIX__DerivativeInstrAttribTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeInstrAttribType *) x));
}
static void *_p_FIX__NestedInstrAttribTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NestedInstrAttribType *) x));
}
static void *_p_FIX__InstrAttribTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::InstrAttribType *) x));
}
static void *_p_FIX__ProcessCodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ProcessCode *) x));
}
static void *_p_FIX__UtcDateFieldTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *)  ((FIX::UtcDateField *) x));
}
static void *_p_FIX__DoubleFieldTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *)  ((FIX::DoubleField *) x));
}
static void *_p_FIX__ValueOfFuturesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ValueOfFutures *) x));
}
static void *_p_FIX__QuoteQualifierTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::QuoteQualifier *) x));
}
static void *_p_FIX__IOIQualifierTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::IOIQualifier *) x));
}
static void *_p_FIX__CollInquiryQualifierTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollInquiryQualifier *) x));
}
static void *_p_FIX__NoCollInquiryQualifierTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoCollInquiryQualifier *) x));
}
static void *_p_FIX__NoRelationshipRiskInstrumentsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRelationshipRiskInstruments *) x));
}
static void *_p_FIX__NoRiskInstrumentsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRiskInstruments *) x));
}
static void *_p_FIX__ExpQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ExpQty *) x));
}
static void *_p_FIX__LegGrossTradeAmtTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegGrossTradeAmt *) x));
}
static void *_p_FIX__GrossTradeAmtTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::GrossTradeAmt *) x));
}
static void *_p_FIX__SideGrossTradeAmtTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SideGrossTradeAmt *) x));
}
static void *_p_FIX__MinBidSizeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MinBidSize *) x));
}
static void *_p_FIX__DefBidSizeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DefBidSize *) x));
}
static void *_p_FIX__BidSizeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BidSize *) x));
}
static void *_p_FIX__ExpTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ExpType *) x));
}
static void *_p_FIX__LastUpdateTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::LastUpdateTime *) x));
}
static void *_p_FIX__PossDupFlagTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::PossDupFlag *) x));
}
static void *_p_FIX__DerivativeSettlMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DerivativeSettlMethod *) x));
}
static void *_p_FIX__InstrmtAssignmentMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::InstrmtAssignmentMethod *) x));
}
static void *_p_FIX__DerivativeValuationMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeValuationMethod *) x));
}
static void *_p_FIX__DerivativeInstrmtAssignmentMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DerivativeInstrmtAssignmentMethod *) x));
}
static void *_p_FIX__SettlMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlMethod *) x));
}
static void *_p_FIX__FuturesValuationMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::FuturesValuationMethod *) x));
}
static void *_p_FIX__UnderlyingPriceDeterminationMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingPriceDeterminationMethod *) x));
}
static void *_p_FIX__PaymentMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PaymentMethod *) x));
}
static void *_p_FIX__StrikePriceDeterminationMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StrikePriceDeterminationMethod *) x));
}
static void *_p_FIX__UnderlyingSettlMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSettlMethod *) x));
}
static void *_p_FIX__DistribPaymentMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DistribPaymentMethod *) x));
}
static void *_p_FIX__ValuationMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ValuationMethod *) x));
}
static void *_p_FIX__EncryptMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncryptMethod *) x));
}
static void *_p_FIX__AssignmentMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::AssignmentMethod *) x));
}
static void *_p_FIX__DerivativeFuturesValuationMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeFuturesValuationMethod *) x));
}
static void *_p_FIX__ListMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ListMethod *) x));
}
static void *_p_FIX__LegLastForwardPointsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegLastForwardPoints *) x));
}
static void *_p_FIX__LegOfferForwardPointsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegOfferForwardPoints *) x));
}
static void *_p_FIX__OfferForwardPointsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OfferForwardPoints *) x));
}
static void *_p_FIX__MDEntryForwardPointsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MDEntryForwardPoints *) x));
}
static void *_p_FIX__BidSwapPointsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BidSwapPoints *) x));
}
static void *_p_FIX__OfferSwapPointsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OfferSwapPoints *) x));
}
static void *_p_FIX__BidForwardPointsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BidForwardPoints *) x));
}
static void *_p_FIX__MaxMessageSizeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MaxMessageSize *) x));
}
static void *_p_FIX__SwapPointsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SwapPoints *) x));
}
static void *_p_FIX__LastForwardPointsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LastForwardPoints *) x));
}
static void *_p_FIX__EncryptedPasswordMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncryptedPasswordMethod *) x));
}
static void *_p_FIX__LegBidForwardPointsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegBidForwardPoints *) x));
}
static void *_p_FIX__DerivativeListMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeListMethod *) x));
}
static void *_p_FIX__LastSwapPointsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LastSwapPoints *) x));
}
static void *_p_FIX__SideTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::Side *) x));
}
static void *_p_FIX__MemoryStoreTo_p_FIX__MessageStore(void *x) {
    return (void *)((FIX::MessageStore *)  ((FIX::MemoryStore *) x));
}
static void *_p_FIX__FileStoreTo_p_FIX__MessageStore(void *x) {
    return (void *)((FIX::MessageStore *)  ((FIX::FileStore *) x));
}
static void *_p_FIX__ScreenLogFactoryTo_p_FIX__LogFactory(void *x) {
    return (void *)((FIX::LogFactory *)  ((FIX::ScreenLogFactory *) x));
}
static void *_p_FIX__FileLogFactoryTo_p_FIX__LogFactory(void *x) {
    return (void *)((FIX::LogFactory *)  ((FIX::FileLogFactory *) x));
}
static void *_p_FIX__MemoryStoreFactoryTo_p_FIX__MessageStoreFactory(void *x) {
    return (void *)((FIX::MessageStoreFactory *)  ((FIX::MemoryStoreFactory *) x));
}
static void *_p_FIX__FileStoreFactoryTo_p_FIX__MessageStoreFactory(void *x) {
    return (void *)((FIX::MessageStoreFactory *)  ((FIX::FileStoreFactory *) x));
}
static void *_p_FIX__DeliveryDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DeliveryDate *) x));
}
static void *_p_FIX__RFQReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RFQReqID *) x));
}
static void *_p_FIX__TradeConditionTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TradeCondition *) x));
}
static void *_p_FIX__EncodedTextTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedText *) x));
}
static void *_p_FIX__QuoteConditionTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::QuoteCondition *) x));
}
static void *_p_FIX__ExchangeRuleTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ExchangeRule *) x));
}
static void *_p_FIX__FutSettDate2To_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::FutSettDate2 *) x));
}
static void *_p_FIX__CollAsgnIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CollAsgnID *) x));
}
static void *_p_FIX__TradeRequestIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TradeRequestID *) x));
}
static void *_p_FIX__UserRequestIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UserRequestID *) x));
}
static void *_p_FIX__NetworkRequestIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::NetworkRequestID *) x));
}
static void *_p_FIX__PartyDetailsListRequestIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PartyDetailsListRequestID *) x));
}
static void *_p_FIX__ClientBidIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ClientBidID *) x));
}
static void *_p_FIX__ReferencePageTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ReferencePage *) x));
}
static void *_p_FIX__UserStatusTextTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UserStatusText *) x));
}
static void *_p_FIX__MDFeedTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MDFeedType *) x));
}
static void *_p_FIX__StatusTextTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::StatusText *) x));
}
static void *_p_FIX__ListStatusTextTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ListStatusText *) x));
}
static void *_p_FIX__EncodedListStatusTextTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedListStatusText *) x));
}
static void *_p_FIX__DeskTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DeskType *) x));
}
static void *_p_FIX__SettlDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlDate *) x));
}
static void *_p_FIX__LegSettlDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegSettlDate *) x));
}
static void *_p_FIX__PriceUnitOfMeasureTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PriceUnitOfMeasure *) x));
}
static void *_p_FIX__UnitOfMeasureTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnitOfMeasure *) x));
}
static void *_p_FIX__DerivativePriceUnitOfMeasureTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativePriceUnitOfMeasure *) x));
}
static void *_p_FIX__DerivativeUnitOfMeasureTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeUnitOfMeasure *) x));
}
static void *_p_FIX__LegPriceUnitOfMeasureTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegPriceUnitOfMeasure *) x));
}
static void *_p_FIX__LegUnitOfMeasureTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegUnitOfMeasure *) x));
}
static void *_p_FIX__UnderlyingUnitOfMeasureTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingUnitOfMeasure *) x));
}
static void *_p_FIX__UnderlyingPriceUnitOfMeasureTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingPriceUnitOfMeasure *) x));
}
static void *_p_FIX__TransferReasonTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TransferReason *) x));
}
static void *_p_FIX__InstrRegistryTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::InstrRegistry *) x));
}
static void *_p_FIX__LegInstrRegistryTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegInstrRegistry *) x));
}
static void *_p_FIX__DerivativeInstrRegistryTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeInstrRegistry *) x));
}
static void *_p_FIX__UnderlyingInstrRegistryTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingInstrRegistry *) x));
}
static void *_p_FIX__DerivativeSecurityDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityDesc *) x));
}
static void *_p_FIX__TriggerSecurityDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TriggerSecurityDesc *) x));
}
static void *_p_FIX__PegSecurityDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PegSecurityDesc *) x));
}
static void *_p_FIX__UnderlyingLegSecurityDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSecurityDesc *) x));
}
static void *_p_FIX__RelationshipRiskSecurityDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskSecurityDesc *) x));
}
static void *_p_FIX__EncodedSecurityDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedSecurityDesc *) x));
}
static void *_p_FIX__UnderlyingSecurityDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSecurityDesc *) x));
}
static void *_p_FIX__RiskEncodedSecurityDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskEncodedSecurityDesc *) x));
}
static void *_p_FIX__SecurityDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityDesc *) x));
}
static void *_p_FIX__EncodedUnderlyingSecurityDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedUnderlyingSecurityDesc *) x));
}
static void *_p_FIX__EncodedLegSecurityDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedLegSecurityDesc *) x));
}
static void *_p_FIX__DerivativeEncodedSecurityDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeEncodedSecurityDesc *) x));
}
static void *_p_FIX__LegSecurityDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegSecurityDesc *) x));
}
static void *_p_FIX__RelationshipRiskEncodedSecurityDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskEncodedSecurityDesc *) x));
}
static void *_p_FIX__RiskSecurityDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskSecurityDesc *) x));
}
static void *_p_FIX__UsernameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Username *) x));
}
static void *_p_FIX__SettlBrkrCodeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlBrkrCode *) x));
}
static void *_p_FIX__TextTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Text *) x));
}
static void *_p_FIX__RegistRejReasonTextTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RegistRejReasonText *) x));
}
static void *_p_FIX__ApplIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ApplID *) x));
}
static void *_p_FIX__RefApplIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RefApplID *) x));
}
static void *_p_FIX__SideTrdRegTimestampSrcTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SideTrdRegTimestampSrc *) x));
}
static void *_p_FIX__SendingDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SendingDate *) x));
}
static void *_p_FIX__RiskLimitPlatformTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskLimitPlatform *) x));
}
static void *_p_FIX__RelationshipRiskLimitPlatformTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskLimitPlatform *) x));
}
static void *_p_FIX__UndlyInstrumentPartyIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UndlyInstrumentPartyID *) x));
}
static void *_p_FIX__TargetPartyIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TargetPartyID *) x));
}
static void *_p_FIX__RelatedContextPartyIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelatedContextPartyID *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartyIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingInstrumentPartyID *) x));
}
static void *_p_FIX__NestedPartyIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::NestedPartyID *) x));
}
static void *_p_FIX__RelatedPartyIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelatedPartyID *) x));
}
static void *_p_FIX__Nested3PartyIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Nested3PartyID *) x));
}
static void *_p_FIX__CollInquiryIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CollInquiryID *) x));
}
static void *_p_FIX__SettlPartyIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlPartyID *) x));
}
static void *_p_FIX__ContextPartyIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ContextPartyID *) x));
}
static void *_p_FIX__Nested4PartyIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Nested4PartyID *) x));
}
static void *_p_FIX__PartyIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PartyID *) x));
}
static void *_p_FIX__RootPartyIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RootPartyID *) x));
}
static void *_p_FIX__DerivativeInstrumentPartyIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeInstrumentPartyID *) x));
}
static void *_p_FIX__InstrumentPartyIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::InstrumentPartyID *) x));
}
static void *_p_FIX__Nested2PartyIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Nested2PartyID *) x));
}
static void *_p_FIX__SettlSessIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlSessID *) x));
}
static void *_p_FIX__MarketSegmentDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MarketSegmentDesc *) x));
}
static void *_p_FIX__AgreementDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AgreementDesc *) x));
}
static void *_p_FIX__QuoteReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::QuoteReqID *) x));
}
static void *_p_FIX__ExecIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ExecID *) x));
}
static void *_p_FIX__FillExecIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::FillExecID *) x));
}
static void *_p_FIX__SecondaryExecIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryExecID *) x));
}
static void *_p_FIX__SideExecIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SideExecID *) x));
}
static void *_p_FIX__CashSettlAgentNameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CashSettlAgentName *) x));
}
static void *_p_FIX__CashDistribAgentNameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CashDistribAgentName *) x));
}
static void *_p_FIX__SecuritySettlAgentNameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecuritySettlAgentName *) x));
}
static void *_p_FIX__MDEntryOriginatorTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MDEntryOriginator *) x));
}
static void *_p_FIX__LegStipulationTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegStipulationType *) x));
}
static void *_p_FIX__PoolTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Pool *) x));
}
static void *_p_FIX__StipulationTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::StipulationType *) x));
}
static void *_p_FIX__SettlInstCodeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlInstCode *) x));
}
static void *_p_FIX__MailingDtlsTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MailingDtls *) x));
}
static void *_p_FIX__LegSecurityAltIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegSecurityAltID *) x));
}
static void *_p_FIX__RelatedPartyAltIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelatedPartyAltID *) x));
}
static void *_p_FIX__RelationshipRiskSecurityAltIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskSecurityAltID *) x));
}
static void *_p_FIX__NoLegSecurityAltIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::NoLegSecurityAltID *) x));
}
static void *_p_FIX__SecurityAltIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityAltID *) x));
}
static void *_p_FIX__PartyAltIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PartyAltID *) x));
}
static void *_p_FIX__UnderlyingLegSecurityAltIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSecurityAltID *) x));
}
static void *_p_FIX__DerivativeSecurityAltIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityAltID *) x));
}
static void *_p_FIX__UnderlyingSecurityAltIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSecurityAltID *) x));
}
static void *_p_FIX__RiskSecurityAltIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskSecurityAltID *) x));
}
static void *_p_FIX__EncodedAllocTextTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedAllocText *) x));
}
static void *_p_FIX__AllocTextTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AllocText *) x));
}
static void *_p_FIX__ClientIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ClientID *) x));
}
static void *_p_FIX__TargetSubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TargetSubID *) x));
}
static void *_p_FIX__PartyAltSubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PartyAltSubID *) x));
}
static void *_p_FIX__RelatdSymTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelatdSym *) x));
}
static void *_p_FIX__RelatedPartyAltSubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelatedPartyAltSubID *) x));
}
static void *_p_FIX__SecuritySettlAgentContactNameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecuritySettlAgentContactName *) x));
}
static void *_p_FIX__SecuritySettlAgentAcctNameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecuritySettlAgentAcctName *) x));
}
static void *_p_FIX__CashDistribAgentAcctNameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CashDistribAgentAcctName *) x));
}
static void *_p_FIX__CashSettlAgentAcctNameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CashSettlAgentAcctName *) x));
}
static void *_p_FIX__CashSettlAgentContactNameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CashSettlAgentContactName *) x));
}
static void *_p_FIX__ApplVerIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ApplVerID *) x));
}
static void *_p_FIX__RefCstmApplVerIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RefCstmApplVerID *) x));
}
static void *_p_FIX__DefaultApplVerIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DefaultApplVerID *) x));
}
static void *_p_FIX__CstmApplVerIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CstmApplVerID *) x));
}
static void *_p_FIX__RefApplVerIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RefApplVerID *) x));
}
static void *_p_FIX__DefaultCstmApplVerIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DefaultCstmApplVerID *) x));
}
static void *_p_FIX__CountryTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Country *) x));
}
static void *_p_FIX__CardHolderNameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CardHolderName *) x));
}
static void *_p_FIX__StrategyParameterNameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::StrategyParameterName *) x));
}
static void *_p_FIX__SenderLocationIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SenderLocationID *) x));
}
static void *_p_FIX__LocationIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LocationID *) x));
}
static void *_p_FIX__TargetLocationIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TargetLocationID *) x));
}
static void *_p_FIX__OnBehalfOfLocationIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::OnBehalfOfLocationID *) x));
}
static void *_p_FIX__DeliverToLocationIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DeliverToLocationID *) x));
}
static void *_p_FIX__TradeInputDeviceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TradeInputDevice *) x));
}
static void *_p_FIX__OrderInputDeviceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::OrderInputDevice *) x));
}
static void *_p_FIX__AllowableOneSidednessCurrTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AllowableOneSidednessCurr *) x));
}
static void *_p_FIX__LegAllocSettlCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegAllocSettlCurrency *) x));
}
static void *_p_FIX__PositionCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PositionCurrency *) x));
}
static void *_p_FIX__UnderlyingCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingCurrency *) x));
}
static void *_p_FIX__CommCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CommCurrency *) x));
}
static void *_p_FIX__UnderlyingStrikeCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingStrikeCurrency *) x));
}
static void *_p_FIX__DerivativeStrikeCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeStrikeCurrency *) x));
}
static void *_p_FIX__AgreementCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AgreementCurrency *) x));
}
static void *_p_FIX__AllocSettlCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AllocSettlCurrency *) x));
}
static void *_p_FIX__TradingCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TradingCurrency *) x));
}
static void *_p_FIX__CurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Currency *) x));
}
static void *_p_FIX__StrikeCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::StrikeCurrency *) x));
}
static void *_p_FIX__SettlCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlCurrency *) x));
}
static void *_p_FIX__LegSettlCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegSettlCurrency *) x));
}
static void *_p_FIX__LegCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegCurrency *) x));
}
static void *_p_FIX__SideCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SideCurrency *) x));
}
static void *_p_FIX__BenchmarkCurveCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::BenchmarkCurveCurrency *) x));
}
static void *_p_FIX__LegBenchmarkCurveCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegBenchmarkCurveCurrency *) x));
}
static void *_p_FIX__SideSettlCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SideSettlCurrency *) x));
}
static void *_p_FIX__RiskLimitCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskLimitCurrency *) x));
}
static void *_p_FIX__RelationshipRiskLimitCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskLimitCurrency *) x));
}
static void *_p_FIX__LegStrikeCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegStrikeCurrency *) x));
}
static void *_p_FIX__ClearingFeeIndicatorTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ClearingFeeIndicator *) x));
}
static void *_p_FIX__AllocClearingFeeIndicatorTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AllocClearingFeeIndicator *) x));
}
static void *_p_FIX__UnderlyingSettlementStatusTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSettlementStatus *) x));
}
static void *_p_FIX__FinancialStatusTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::FinancialStatus *) x));
}
static void *_p_FIX__AllocCustomerCapacityTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AllocCustomerCapacity *) x));
}
static void *_p_FIX__SecurityStatusTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityStatus *) x));
}
static void *_p_FIX__DerivativeSecurityStatusTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityStatus *) x));
}
static void *_p_FIX__MDReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MDReqID *) x));
}
static void *_p_FIX__MDEntryRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MDEntryRefID *) x));
}
static void *_p_FIX__StandInstDbIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::StandInstDbID *) x));
}
static void *_p_FIX__SettlInstMsgIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlInstMsgID *) x));
}
static void *_p_FIX__SignatureTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Signature *) x));
}
static void *_p_FIX__BrokerOfCreditTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::BrokerOfCredit *) x));
}
static void *_p_FIX__OrigTradeDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::OrigTradeDate *) x));
}
static void *_p_FIX__TradeDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TradeDate *) x));
}
static void *_p_FIX__DatedDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DatedDate *) x));
}
static void *_p_FIX__LegDatedDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegDatedDate *) x));
}
static void *_p_FIX__CrossIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CrossID *) x));
}
static void *_p_FIX__OrigCrossIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::OrigCrossID *) x));
}
static void *_p_FIX__HostCrossIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::HostCrossID *) x));
}
static void *_p_FIX__CollAsgnRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CollAsgnRefID *) x));
}
static void *_p_FIX__SecurityReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityReqID *) x));
}
static void *_p_FIX__OpenCloseSettlFlagTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::OpenCloseSettlFlag *) x));
}
static void *_p_FIX__RefOrderIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RefOrderID *) x));
}
static void *_p_FIX__SecondaryOrderIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryOrderID *) x));
}
static void *_p_FIX__MailingInstTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MailingInst *) x));
}
static void *_p_FIX__AffectedSecondaryOrderIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AffectedSecondaryOrderID *) x));
}
static void *_p_FIX__NotAffectedOrderIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::NotAffectedOrderID *) x));
}
static void *_p_FIX__OrderIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::OrderID *) x));
}
static void *_p_FIX__AffectedOrderIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AffectedOrderID *) x));
}
static void *_p_FIX__CustOrderHandlingInstTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CustOrderHandlingInst *) x));
}
static void *_p_FIX__DeskOrderHandlingInstTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DeskOrderHandlingInst *) x));
}
static void *_p_FIX__SettlSessSubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlSessSubID *) x));
}
static void *_p_FIX__LegBenchmarkCurvePointTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegBenchmarkCurvePoint *) x));
}
static void *_p_FIX__BenchmarkCurvePointTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::BenchmarkCurvePoint *) x));
}
static void *_p_FIX__ContraTraderTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ContraTrader *) x));
}
static void *_p_FIX__PaymentRefTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PaymentRef *) x));
}
static void *_p_FIX__TradingSessionIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TradingSessionID *) x));
}
static void *_p_FIX__TriggerTradingSessionIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TriggerTradingSessionID *) x));
}
static void *_p_FIX__UnderlyingTradingSessionIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingTradingSessionID *) x));
}
static void *_p_FIX__StreamAsgnReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::StreamAsgnReqID *) x));
}
static void *_p_FIX__AsgnReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AsgnReqID *) x));
}
static void *_p_FIX__SettlInstIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlInstID *) x));
}
static void *_p_FIX__ExecRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ExecRefID *) x));
}
static void *_p_FIX__LegFutSettDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegFutSettDate *) x));
}
static void *_p_FIX__FutSettDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::FutSettDate *) x));
}
static void *_p_FIX__CardExpDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CardExpDate *) x));
}
static void *_p_FIX__ExDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ExDate *) x));
}
static void *_p_FIX__QuoteSetIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::QuoteSetID *) x));
}
static void *_p_FIX__CashDistribAgentAcctNumberTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CashDistribAgentAcctNumber *) x));
}
static void *_p_FIX__CardNumberTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CardNumber *) x));
}
static void *_p_FIX__LastNetworkResponseIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LastNetworkResponseID *) x));
}
static void *_p_FIX__SecurityResponseIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityResponseID *) x));
}
static void *_p_FIX__NetworkResponseIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::NetworkResponseID *) x));
}
static void *_p_FIX__ApplResponseIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ApplResponseID *) x));
}
static void *_p_FIX__LastMktTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LastMkt *) x));
}
static void *_p_FIX__MDEntrySellerTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MDEntrySeller *) x));
}
static void *_p_FIX__RedemptionDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RedemptionDate *) x));
}
static void *_p_FIX__TradeOriginationDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TradeOriginationDate *) x));
}
static void *_p_FIX__LegRedemptionDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegRedemptionDate *) x));
}
static void *_p_FIX__TradeIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TradeID *) x));
}
static void *_p_FIX__SecondaryFirmTradeIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryFirmTradeID *) x));
}
static void *_p_FIX__FirmTradeIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::FirmTradeID *) x));
}
static void *_p_FIX__SecondaryTradeIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryTradeID *) x));
}
static void *_p_FIX__OrigTradeIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::OrigTradeID *) x));
}
static void *_p_FIX__UnderlyingRedemptionDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingRedemptionDate *) x));
}
static void *_p_FIX__YieldRedemptionDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::YieldRedemptionDate *) x));
}
static void *_p_FIX__OrigSecondaryTradeIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::OrigSecondaryTradeID *) x));
}
static void *_p_FIX__InvestorCountryOfResidenceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::InvestorCountryOfResidence *) x));
}
static void *_p_FIX__CreditRatingTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CreditRating *) x));
}
static void *_p_FIX__LegCreditRatingTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegCreditRating *) x));
}
static void *_p_FIX__UnderlyingCreditRatingTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingCreditRating *) x));
}
static void *_p_FIX__ConfirmRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ConfirmRefID *) x));
}
static void *_p_FIX__MDEntryBuyerTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MDEntryBuyer *) x));
}
static void *_p_FIX__IOIIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::IOIID *) x));
}
static void *_p_FIX__UnderlyingCashTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingCashType *) x));
}
static void *_p_FIX__SenderSubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SenderSubID *) x));
}
static void *_p_FIX__TrdRegTimestampOriginTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TrdRegTimestampOrigin *) x));
}
static void *_p_FIX__AdvIdTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AdvId *) x));
}
static void *_p_FIX__TrdMatchIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TrdMatchID *) x));
}
static void *_p_FIX__ConfirmReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ConfirmReqID *) x));
}
static void *_p_FIX__MaturityRuleIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MaturityRuleID *) x));
}
static void *_p_FIX__StrikeRuleIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::StrikeRuleID *) x));
}
static void *_p_FIX__TriggerSecurityIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TriggerSecurityID *) x));
}
static void *_p_FIX__LegSecurityIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegSecurityID *) x));
}
static void *_p_FIX__SecurityIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityID *) x));
}
static void *_p_FIX__BenchmarkSecurityIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::BenchmarkSecurityID *) x));
}
static void *_p_FIX__DerivativeSecurityIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityID *) x));
}
static void *_p_FIX__PegSecurityIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PegSecurityID *) x));
}
static void *_p_FIX__RiskSecurityIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskSecurityID *) x));
}
static void *_p_FIX__UnderlyingSecurityIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSecurityID *) x));
}
static void *_p_FIX__UnderlyingLegSecurityIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSecurityID *) x));
}
static void *_p_FIX__RelationshipRiskSecurityIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskSecurityID *) x));
}
static void *_p_FIX__RefCompIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RefCompID *) x));
}
static void *_p_FIX__SenderCompIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SenderCompID *) x));
}
static void *_p_FIX__TargetCompIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TargetCompID *) x));
}
static void *_p_FIX__HopCompIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::HopCompID *) x));
}
static void *_p_FIX__OnBehalfOfCompIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::OnBehalfOfCompID *) x));
}
static void *_p_FIX__CashSettlAgentContactPhoneTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CashSettlAgentContactPhone *) x));
}
static void *_p_FIX__SecuritySettlAgentContactPhoneTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecuritySettlAgentContactPhone *) x));
}
static void *_p_FIX__DeliverToCompIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DeliverToCompID *) x));
}
static void *_p_FIX__ConfirmIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ConfirmID *) x));
}
static void *_p_FIX__EndDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EndDate *) x));
}
static void *_p_FIX__LegStateOrProvinceOfIssueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegStateOrProvinceOfIssue *) x));
}
static void *_p_FIX__LegCountryOfIssueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegCountryOfIssue *) x));
}
static void *_p_FIX__UnderlyingStateOrProvinceOfIssueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingStateOrProvinceOfIssue *) x));
}
static void *_p_FIX__DerivativeCountryOfIssueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeCountryOfIssue *) x));
}
static void *_p_FIX__DerivativeStateOrProvinceOfIssueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeStateOrProvinceOfIssue *) x));
}
static void *_p_FIX__YieldTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::YieldType *) x));
}
static void *_p_FIX__UnderlyingCountryOfIssueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingCountryOfIssue *) x));
}
static void *_p_FIX__LocaleOfIssueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LocaleOfIssue *) x));
}
static void *_p_FIX__LegLocaleOfIssueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegLocaleOfIssue *) x));
}
static void *_p_FIX__StateOrProvinceOfIssueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::StateOrProvinceOfIssue *) x));
}
static void *_p_FIX__CountryOfIssueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CountryOfIssue *) x));
}
static void *_p_FIX__DerivativeLocaleOfIssueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeLocaleOfIssue *) x));
}
static void *_p_FIX__UnderlyingLocaleOfIssueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLocaleOfIssue *) x));
}
static void *_p_FIX__EncodedSymbolTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedSymbol *) x));
}
static void *_p_FIX__SymbolTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Symbol *) x));
}
static void *_p_FIX__TriggerSymbolTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TriggerSymbol *) x));
}
static void *_p_FIX__UnderlyingLegSymbolTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSymbol *) x));
}
static void *_p_FIX__PegSymbolTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PegSymbol *) x));
}
static void *_p_FIX__RiskSymbolTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskSymbol *) x));
}
static void *_p_FIX__UnderlyingSymbolTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSymbol *) x));
}
static void *_p_FIX__LegSymbolTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegSymbol *) x));
}
static void *_p_FIX__DerivativeSymbolTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSymbol *) x));
}
static void *_p_FIX__RelationshipRiskSymbolTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskSymbol *) x));
}
static void *_p_FIX__AltMDSourceIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AltMDSourceID *) x));
}
static void *_p_FIX__StrategyParameterValueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::StrategyParameterValue *) x));
}
static void *_p_FIX__UnderlyingSettlMethodTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSettlMethod *) x));
}
static void *_p_FIX__DerivativeFuturesValuationMethodTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeFuturesValuationMethod *) x));
}
static void *_p_FIX__ValuationMethodTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ValuationMethod *) x));
}
static void *_p_FIX__BeginStringTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::BeginString *) x));
}
static void *_p_FIX__FuturesValuationMethodTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::FuturesValuationMethod *) x));
}
static void *_p_FIX__DerivativeValuationMethodTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeValuationMethod *) x));
}
static void *_p_FIX__DerivativePriceQuoteMethodTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativePriceQuoteMethod *) x));
}
static void *_p_FIX__PriceQuoteMethodTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PriceQuoteMethod *) x));
}
static void *_p_FIX__WaveNoTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::WaveNo *) x));
}
static void *_p_FIX__RegistDtlsTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RegistDtls *) x));
}
static void *_p_FIX__NewPasswordTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::NewPassword *) x));
}
static void *_p_FIX__EncryptedNewPasswordTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncryptedNewPassword *) x));
}
static void *_p_FIX__PasswordTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Password *) x));
}
static void *_p_FIX__SettlObligMsgIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlObligMsgID *) x));
}
static void *_p_FIX__EncryptedPasswordTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncryptedPassword *) x));
}
static void *_p_FIX__IOIQtyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::IOIQty *) x));
}
static void *_p_FIX__MessageEncodingTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MessageEncoding *) x));
}
static void *_p_FIX__LegIOIQtyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegIOIQty *) x));
}
static void *_p_FIX__RefMsgTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RefMsgType *) x));
}
static void *_p_FIX__MsgTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MsgType *) x));
}
static void *_p_FIX__EncodedMktSegmDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedMktSegmDesc *) x));
}
static void *_p_FIX__SettleOnOpenFlagTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettleOnOpenFlag *) x));
}
static void *_p_FIX__DerivativeSettleOnOpenFlagTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSettleOnOpenFlag *) x));
}
static void *_p_FIX__ApplReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ApplReqID *) x));
}
static void *_p_FIX__RefApplReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RefApplReqID *) x));
}
static void *_p_FIX__CollReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CollReqID *) x));
}
static void *_p_FIX__DerivativeSecurityXMLTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityXML *) x));
}
static void *_p_FIX__SecurityXMLTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityXML *) x));
}
static void *_p_FIX__TargetStrategyParametersTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TargetStrategyParameters *) x));
}
static void *_p_FIX__BidIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::BidID *) x));
}
static void *_p_FIX__RiskSecurityGroupTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskSecurityGroup *) x));
}
static void *_p_FIX__DerivativeSecurityGroupTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityGroup *) x));
}
static void *_p_FIX__UnderlyingSeniorityTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSeniority *) x));
}
static void *_p_FIX__StartDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::StartDate *) x));
}
static void *_p_FIX__RiskSeniorityTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskSeniority *) x));
}
static void *_p_FIX__RelationshipRiskSecurityGroupTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskSecurityGroup *) x));
}
static void *_p_FIX__SecurityGroupTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityGroup *) x));
}
static void *_p_FIX__RelationshipRiskSeniorityTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskSeniority *) x));
}
static void *_p_FIX__CardStartDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CardStartDate *) x));
}
static void *_p_FIX__SeniorityTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Seniority *) x));
}
static void *_p_FIX__RefSubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RefSubID *) x));
}
static void *_p_FIX__OnBehalfOfSubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::OnBehalfOfSubID *) x));
}
static void *_p_FIX__ClearingBusinessDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ClearingBusinessDate *) x));
}
static void *_p_FIX__ListIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ListID *) x));
}
static void *_p_FIX__MatchAlgorithmTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MatchAlgorithm *) x));
}
static void *_p_FIX__SecurityListIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityListID *) x));
}
static void *_p_FIX__CashDistribPayRefTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CashDistribPayRef *) x));
}
static void *_p_FIX__LegExecInstTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegExecInst *) x));
}
static void *_p_FIX__EncodedListExecInstTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedListExecInst *) x));
}
static void *_p_FIX__ExecInstTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ExecInst *) x));
}
static void *_p_FIX__ListExecInstTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ListExecInst *) x));
}
static void *_p_FIX__SecondaryClOrdIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryClOrdID *) x));
}
static void *_p_FIX__ClOrdIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ClOrdID *) x));
}
static void *_p_FIX__OrigClOrdIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::OrigClOrdID *) x));
}
static void *_p_FIX__NotAffOrigClOrdIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::NotAffOrigClOrdID *) x));
}
static void *_p_FIX__AdvRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AdvRefID *) x));
}
static void *_p_FIX__URLLinkTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::URLLink *) x));
}
static void *_p_FIX__SideReasonCdTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SideReasonCd *) x));
}
static void *_p_FIX__UnderlyingStipTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingStipType *) x));
}
static void *_p_FIX__PaymentRemitterIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PaymentRemitterID *) x));
}
static void *_p_FIX__RelationshipRiskCFICodeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskCFICode *) x));
}
static void *_p_FIX__RiskCFICodeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskCFICode *) x));
}
static void *_p_FIX__LegCFICodeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegCFICode *) x));
}
static void *_p_FIX__DerivativeCFICodeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeCFICode *) x));
}
static void *_p_FIX__AsgnRptIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AsgnRptID *) x));
}
static void *_p_FIX__UnderlyingCFICodeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingCFICode *) x));
}
static void *_p_FIX__StreamAsgnRptIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::StreamAsgnRptID *) x));
}
static void *_p_FIX__CFICodeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CFICode *) x));
}
static void *_p_FIX__UnderlyingLegCFICodeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegCFICode *) x));
}
static void *_p_FIX__ApplReportIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ApplReportID *) x));
}
static void *_p_FIX__SideTradeReportIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SideTradeReportID *) x));
}
static void *_p_FIX__AllocReportIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AllocReportID *) x));
}
static void *_p_FIX__TradeReportIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TradeReportID *) x));
}
static void *_p_FIX__LegReportIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegReportID *) x));
}
static void *_p_FIX__MarketReportIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MarketReportID *) x));
}
static void *_p_FIX__MassActionReportIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MassActionReportID *) x));
}
static void *_p_FIX__RoutingIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RoutingID *) x));
}
static void *_p_FIX__SecondaryTradeReportIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryTradeReportID *) x));
}
static void *_p_FIX__PartyDetailsListReportIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PartyDetailsListReportID *) x));
}
static void *_p_FIX__IOIidTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::IOIid *) x));
}
static void *_p_FIX__ExchangeSpecialInstructionsTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ExchangeSpecialInstructions *) x));
}
static void *_p_FIX__OrderRestrictionsTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::OrderRestrictions *) x));
}
static void *_p_FIX__TimeUnitTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TimeUnit *) x));
}
static void *_p_FIX__LegTimeUnitTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegTimeUnit *) x));
}
static void *_p_FIX__DerivativeTimeUnitTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeTimeUnit *) x));
}
static void *_p_FIX__UnderlyingTimeUnitTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingTimeUnit *) x));
}
static void *_p_FIX__ExecBrokerTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ExecBroker *) x));
}
static void *_p_FIX__ContraBrokerTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ContraBroker *) x));
}
static void *_p_FIX__NewsIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::NewsID *) x));
}
static void *_p_FIX__ParentMktSegmIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ParentMktSegmID *) x));
}
static void *_p_FIX__SubjectTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Subject *) x));
}
static void *_p_FIX__EncodedSubjectTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedSubject *) x));
}
static void *_p_FIX__UnderlyingStipValueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingStipValue *) x));
}
static void *_p_FIX__DerivativeSecurityXMLSchemaTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityXMLSchema *) x));
}
static void *_p_FIX__SecurityXMLSchemaTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityXMLSchema *) x));
}
static void *_p_FIX__DerivativeEventTextTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeEventText *) x));
}
static void *_p_FIX__EventTextTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EventText *) x));
}
static void *_p_FIX__TradingSessionDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TradingSessionDesc *) x));
}
static void *_p_FIX__AllocIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AllocID *) x));
}
static void *_p_FIX__LegIndividualAllocIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegIndividualAllocID *) x));
}
static void *_p_FIX__LegAllocIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegAllocID *) x));
}
static void *_p_FIX__SecondaryIndividualAllocIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryIndividualAllocID *) x));
}
static void *_p_FIX__RefAllocIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RefAllocID *) x));
}
static void *_p_FIX__IndividualAllocIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::IndividualAllocID *) x));
}
static void *_p_FIX__SecondaryAllocIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryAllocID *) x));
}
static void *_p_FIX__CardIssNumTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CardIssNum *) x));
}
static void *_p_FIX__UnderlyingLegSecurityTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSecurityType *) x));
}
static void *_p_FIX__DerivativeSecurityTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityType *) x));
}
static void *_p_FIX__LegSecurityTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegSecurityType *) x));
}
static void *_p_FIX__CashDistribAgentCodeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CashDistribAgentCode *) x));
}
static void *_p_FIX__RiskSecurityTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskSecurityType *) x));
}
static void *_p_FIX__SecurityTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityType *) x));
}
static void *_p_FIX__UnderlyingSecurityTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSecurityType *) x));
}
static void *_p_FIX__SecuritySettlAgentCodeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecuritySettlAgentCode *) x));
}
static void *_p_FIX__CashSettlAgentCodeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CashSettlAgentCode *) x));
}
static void *_p_FIX__RelationshipRiskSecurityTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskSecurityType *) x));
}
static void *_p_FIX__ReceivedDeptIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ReceivedDeptID *) x));
}
static void *_p_FIX__QuoteMsgIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::QuoteMsgID *) x));
}
static void *_p_FIX__UnderlyingCPProgramTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingCPProgram *) x));
}
static void *_p_FIX__DeliverToSubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DeliverToSubID *) x));
}
static void *_p_FIX__RejectTextTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RejectText *) x));
}
static void *_p_FIX__IOISharesTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::IOIShares *) x));
}
static void *_p_FIX__DerivativeIssueDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeIssueDate *) x));
}
static void *_p_FIX__UnderlyingIssueDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingIssueDate *) x));
}
static void *_p_FIX__IssueDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::IssueDate *) x));
}
static void *_p_FIX__LegIssueDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegIssueDate *) x));
}
static void *_p_FIX__QuoteIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::QuoteID *) x));
}
static void *_p_FIX__SecurityListDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityListDesc *) x));
}
static void *_p_FIX__ClOrdLinkIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ClOrdLinkID *) x));
}
static void *_p_FIX__EncodedSecurityListDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedSecurityListDesc *) x));
}
static void *_p_FIX__TierCodeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TierCode *) x));
}
static void *_p_FIX__TradeLinkIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TradeLinkID *) x));
}
static void *_p_FIX__AllocLinkIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AllocLinkID *) x));
}
static void *_p_FIX__EncodedHeadlineTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedHeadline *) x));
}
static void *_p_FIX__HeadlineTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Headline *) x));
}
static void *_p_FIX__RegistEmailTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RegistEmail *) x));
}
static void *_p_FIX__RiskSecurityAltIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskSecurityAltIDSource *) x));
}
static void *_p_FIX__RelationshipRiskSecurityIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskSecurityIDSource *) x));
}
static void *_p_FIX__MessageEventSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MessageEventSource *) x));
}
static void *_p_FIX__TradeInputSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TradeInputSource *) x));
}
static void *_p_FIX__LegSecurityIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegSecurityIDSource *) x));
}
static void *_p_FIX__IDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::IDSource *) x));
}
static void *_p_FIX__DerivativeSecurityAltIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityAltIDSource *) x));
}
static void *_p_FIX__RiskSecurityIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskSecurityIDSource *) x));
}
static void *_p_FIX__DerivativeSecurityIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityIDSource *) x));
}
static void *_p_FIX__BenchmarkSecurityIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::BenchmarkSecurityIDSource *) x));
}
static void *_p_FIX__DerivativeInstrumentPartyIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeInstrumentPartyIDSource *) x));
}
static void *_p_FIX__SecurityIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityIDSource *) x));
}
static void *_p_FIX__ContAmtCurrTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ContAmtCurr *) x));
}
static void *_p_FIX__UnderlyingLegSecurityAltIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSecurityAltIDSource *) x));
}
static void *_p_FIX__SecurityAltIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityAltIDSource *) x));
}
static void *_p_FIX__UnderlyingIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingIDSource *) x));
}
static void *_p_FIX__RelationshipRiskSecurityAltIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskSecurityAltIDSource *) x));
}
static void *_p_FIX__LegSecurityAltIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegSecurityAltIDSource *) x));
}
static void *_p_FIX__TriggerSecurityIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TriggerSecurityIDSource *) x));
}
static void *_p_FIX__PegSecurityIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PegSecurityIDSource *) x));
}
static void *_p_FIX__InputSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::InputSource *) x));
}
static void *_p_FIX__UnderlyingSecurityIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSecurityIDSource *) x));
}
static void *_p_FIX__LegAllocAcctIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegAllocAcctIDSource *) x));
}
static void *_p_FIX__UnderlyingSecurityAltIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSecurityAltIDSource *) x));
}
static void *_p_FIX__UnderlyingLegSecurityIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSecurityIDSource *) x));
}
static void *_p_FIX__MaturityDayTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MaturityDay *) x));
}
static void *_p_FIX__PosTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PosType *) x));
}
static void *_p_FIX__UnderlyingMaturityDayTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingMaturityDay *) x));
}
static void *_p_FIX__SideComplianceIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SideComplianceID *) x));
}
static void *_p_FIX__ComplianceIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ComplianceID *) x));
}
static void *_p_FIX__ListNameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ListName *) x));
}
static void *_p_FIX__ClearingFirmTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ClearingFirm *) x));
}
static void *_p_FIX__YieldCalcDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::YieldCalcDate *) x));
}
static void *_p_FIX__OpenCloseSettleFlagTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::OpenCloseSettleFlag *) x));
}
static void *_p_FIX__SecurityListRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityListRefID *) x));
}
static void *_p_FIX__SettlInstRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlInstRefID *) x));
}
static void *_p_FIX__BusinessRejectRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::BusinessRejectRefID *) x));
}
static void *_p_FIX__RegistRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RegistRefID *) x));
}
static void *_p_FIX__AllocReportRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AllocReportRefID *) x));
}
static void *_p_FIX__TradeReportRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TradeReportRefID *) x));
}
static void *_p_FIX__PosMaintRptRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PosMaintRptRefID *) x));
}
static void *_p_FIX__SecondaryTradeReportRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryTradeReportRefID *) x));
}
static void *_p_FIX__RegistAcctTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RegistAcctType *) x));
}
static void *_p_FIX__SideFillStationCdTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SideFillStationCd *) x));
}
static void *_p_FIX__Nested2PartySubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Nested2PartySubID *) x));
}
static void *_p_FIX__NestedPartySubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::NestedPartySubID *) x));
}
static void *_p_FIX__ContextPartySubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ContextPartySubID *) x));
}
static void *_p_FIX__InstrumentPartySubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::InstrumentPartySubID *) x));
}
static void *_p_FIX__RelatedContextPartySubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelatedContextPartySubID *) x));
}
static void *_p_FIX__RelatedPartySubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelatedPartySubID *) x));
}
static void *_p_FIX__QuoteEntryIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::QuoteEntryID *) x));
}
static void *_p_FIX__RootPartySubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RootPartySubID *) x));
}
static void *_p_FIX__MDEntryIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MDEntryID *) x));
}
static void *_p_FIX__PartySubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PartySubID *) x));
}
static void *_p_FIX__SettlPartySubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlPartySubID *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartySubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingInstrumentPartySubID *) x));
}
static void *_p_FIX__Nested4PartySubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Nested4PartySubID *) x));
}
static void *_p_FIX__Nested3PartySubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Nested3PartySubID *) x));
}
static void *_p_FIX__DerivativeInstrumentPartySubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeInstrumentPartySubID *) x));
}
static void *_p_FIX__UndlyInstrumentPartySubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UndlyInstrumentPartySubID *) x));
}
static void *_p_FIX__XmlDataTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::XmlData *) x));
}
static void *_p_FIX__MDStreamIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MDStreamID *) x));
}
static void *_p_FIX__SettlInstReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlInstReqID *) x));
}
static void *_p_FIX__MarketReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MarketReqID *) x));
}
static void *_p_FIX__CollRptIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CollRptID *) x));
}
static void *_p_FIX__TestReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TestReqID *) x));
}
static void *_p_FIX__IOIRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::IOIRefID *) x));
}
static void *_p_FIX__SecuritySettlAgentAcctNumTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecuritySettlAgentAcctNum *) x));
}
static void *_p_FIX__CashSettlAgentAcctNumTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CashSettlAgentAcctNum *) x));
}
static void *_p_FIX__LanguageCodeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LanguageCode *) x));
}
static void *_p_FIX__RiskSymbolSfxTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskSymbolSfx *) x));
}
static void *_p_FIX__UnderlyingLegSymbolSfxTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSymbolSfx *) x));
}
static void *_p_FIX__SymbolSfxTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SymbolSfx *) x));
}
static void *_p_FIX__UnderlyingTradingSessionSubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingTradingSessionSubID *) x));
}
static void *_p_FIX__TradingSessionSubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TradingSessionSubID *) x));
}
static void *_p_FIX__TriggerTradingSessionSubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TriggerTradingSessionSubID *) x));
}
static void *_p_FIX__DerivativeSymbolSfxTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSymbolSfx *) x));
}
static void *_p_FIX__UnderlyingSymbolSfxTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSymbolSfx *) x));
}
static void *_p_FIX__LegSymbolSfxTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegSymbolSfx *) x));
}
static void *_p_FIX__RelationshipRiskSymbolSfxTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskSymbolSfx *) x));
}
static void *_p_FIX__AllocAccountTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AllocAccount *) x));
}
static void *_p_FIX__LegAllocAccountTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegAllocAccount *) x));
}
static void *_p_FIX__ClearingAccountTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ClearingAccount *) x));
}
static void *_p_FIX__AccountTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Account *) x));
}
static void *_p_FIX__EncodedIssuerTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedIssuer *) x));
}
static void *_p_FIX__DerivativeEncodedIssuerTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeEncodedIssuer *) x));
}
static void *_p_FIX__IssuerTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Issuer *) x));
}
static void *_p_FIX__EncodedLegIssuerTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedLegIssuer *) x));
}
static void *_p_FIX__UnderlyingIssuerTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingIssuer *) x));
}
static void *_p_FIX__DerivativeIssuerTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeIssuer *) x));
}
static void *_p_FIX__EncodedUnderlyingIssuerTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedUnderlyingIssuer *) x));
}
static void *_p_FIX__LegIssuerTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegIssuer *) x));
}
static void *_p_FIX__BidDescriptorTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::BidDescriptor *) x));
}
static void *_p_FIX__UnderlyingLegSecuritySubTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSecuritySubType *) x));
}
static void *_p_FIX__SecuritySubTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecuritySubType *) x));
}
static void *_p_FIX__RelationshipRiskSecuritySubTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskSecuritySubType *) x));
}
static void *_p_FIX__DerivativeSecuritySubTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecuritySubType *) x));
}
static void *_p_FIX__LegSecuritySubTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegSecuritySubType *) x));
}
static void *_p_FIX__RiskSecuritySubTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskSecuritySubType *) x));
}
static void *_p_FIX__UnderlyingSecuritySubTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSecuritySubType *) x));
}
static void *_p_FIX__ScopeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Scope *) x));
}
static void *_p_FIX__TimeBracketTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TimeBracket *) x));
}
static void *_p_FIX__PosAmtTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PosAmtType *) x));
}
static void *_p_FIX__AdvTransTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AdvTransType *) x));
}
static void *_p_FIX__SettlDepositoryCodeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlDepositoryCode *) x));
}
static void *_p_FIX__RiskWarningLevelNameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskWarningLevelName *) x));
}
static void *_p_FIX__RelationshipRiskWarningLevelNameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskWarningLevelName *) x));
}
static void *_p_FIX__CPRegTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CPRegType *) x));
}
static void *_p_FIX__LegPoolTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegPool *) x));
}
static void *_p_FIX__UnderlyingCPRegTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingCPRegType *) x));
}
static void *_p_FIX__RawDataTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RawData *) x));
}
static void *_p_FIX__MarketIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MarketID *) x));
}
static void *_p_FIX__SettlDate2To_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlDate2 *) x));
}
static void *_p_FIX__DlvyInstTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DlvyInst *) x));
}
static void *_p_FIX__DeskIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DeskID *) x));
}
static void *_p_FIX__NewsRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::NewsRefID *) x));
}
static void *_p_FIX__CashDistribCurrTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CashDistribCurr *) x));
}
static void *_p_FIX__MarketSegmentIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MarketSegmentID *) x));
}
static void *_p_FIX__LegStipulationValueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegStipulationValue *) x));
}
static void *_p_FIX__AgreementIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AgreementID *) x));
}
static void *_p_FIX__StipulationValueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::StipulationValue *) x));
}
static void *_p_FIX__MDMktTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MDMkt *) x));
}
static void *_p_FIX__MaturityDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MaturityDate *) x));
}
static void *_p_FIX__UnderlyingLegMaturityDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegMaturityDate *) x));
}
static void *_p_FIX__QuantityDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::QuantityDate *) x));
}
static void *_p_FIX__DerivativeMaturityDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeMaturityDate *) x));
}
static void *_p_FIX__LegMaturityDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegMaturityDate *) x));
}
static void *_p_FIX__UnderlyingMaturityDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingMaturityDate *) x));
}
static void *_p_FIX__QuoteStatusReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::QuoteStatusReqID *) x));
}
static void *_p_FIX__OrdStatusReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::OrdStatusReqID *) x));
}
static void *_p_FIX__MassStatusReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MassStatusReqID *) x));
}
static void *_p_FIX__TradSesReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TradSesReqID *) x));
}
static void *_p_FIX__PosReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PosReqID *) x));
}
static void *_p_FIX__SecurityStatusReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityStatusReqID *) x));
}
static void *_p_FIX__StandInstDbNameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::StandInstDbName *) x));
}
static void *_p_FIX__LegMaturityTimeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegMaturityTime *) x));
}
static void *_p_FIX__UnderlyingLegMaturityTimeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegMaturityTime *) x));
}
static void *_p_FIX__RelationshipRiskMaturityTimeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskMaturityTime *) x));
}
static void *_p_FIX__DerivativeMaturityTimeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeMaturityTime *) x));
}
static void *_p_FIX__RiskMaturityTimeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskMaturityTime *) x));
}
static void *_p_FIX__UnderlyingMaturityTimeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingMaturityTime *) x));
}
static void *_p_FIX__MaturityTimeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MaturityTime *) x));
}
static void *_p_FIX__DesignationTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Designation *) x));
}
static void *_p_FIX__ExDestinationTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ExDestination *) x));
}
static void *_p_FIX__ResponseDestinationTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ResponseDestination *) x));
}
static void *_p_FIX__LegInterestAccrualDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegInterestAccrualDate *) x));
}
static void *_p_FIX__InterestAccrualDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::InterestAccrualDate *) x));
}
static void *_p_FIX__CardIssNoTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CardIssNo *) x));
}
static void *_p_FIX__LegBenchmarkCurveNameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegBenchmarkCurveName *) x));
}
static void *_p_FIX__BenchmarkCurveNameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::BenchmarkCurveName *) x));
}
static void *_p_FIX__DerivativeEventDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeEventDate *) x));
}
static void *_p_FIX__CouponPaymentDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CouponPaymentDate *) x));
}
static void *_p_FIX__UnderlyingSettlementDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSettlementDate *) x));
}
static void *_p_FIX__UnderlyingCouponPaymentDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingCouponPaymentDate *) x));
}
static void *_p_FIX__PaymentDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PaymentDate *) x));
}
static void *_p_FIX__EventDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EventDate *) x));
}
static void *_p_FIX__AgreementDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AgreementDate *) x));
}
static void *_p_FIX__LegCouponPaymentDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegCouponPaymentDate *) x));
}
static void *_p_FIX__MatchTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MatchType *) x));
}
static void *_p_FIX__CorporateActionTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CorporateAction *) x));
}
static void *_p_FIX__EmailThreadIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EmailThreadID *) x));
}
static void *_p_FIX__SettlLocationTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlLocation *) x));
}
static void *_p_FIX__MiscFeeCurrTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MiscFeeCurr *) x));
}
static void *_p_FIX__SettlTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlType *) x));
}
static void *_p_FIX__RelationshipRiskInstrumentSettlTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskInstrumentSettlType *) x));
}
static void *_p_FIX__RegistDetlsTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RegistDetls *) x));
}
static void *_p_FIX__RiskInstrumentSettlTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskInstrumentSettlType *) x));
}
static void *_p_FIX__TZTransactTimeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TZTransactTime *) x));
}
static void *_p_FIX__ContraLegRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ContraLegRefID *) x));
}
static void *_p_FIX__TradeLegRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TradeLegRefID *) x));
}
static void *_p_FIX__LegRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegRefID *) x));
}
static void *_p_FIX__SettlObligRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlObligRefID *) x));
}
static void *_p_FIX__ContractSettlMonthTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ContractSettlMonth *) x));
}
static void *_p_FIX__LegContractSettlMonthTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegContractSettlMonth *) x));
}
static void *_p_FIX__BookingRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::BookingRefID *) x));
}
static void *_p_FIX__DerivativeContractSettlMonthTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeContractSettlMonth *) x));
}
static void *_p_FIX__SecureDataTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecureData *) x));
}
static void *_p_FIX__NestedInstrAttribValueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::NestedInstrAttribValue *) x));
}
static void *_p_FIX__DerivativeInstrAttribValueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeInstrAttribValue *) x));
}
static void *_p_FIX__InstrAttribValueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::InstrAttribValue *) x));
}
static void *_p_FIX__UnderlyingSecurityExchangeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSecurityExchange *) x));
}
static void *_p_FIX__RiskSecurityExchangeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskSecurityExchange *) x));
}
static void *_p_FIX__RelationshipRiskSecurityExchangeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskSecurityExchange *) x));
}
static void *_p_FIX__LegSecurityExchangeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegSecurityExchange *) x));
}
static void *_p_FIX__SecurityExchangeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityExchange *) x));
}
static void *_p_FIX__UnderlyingLegSecurityExchangeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSecurityExchange *) x));
}
static void *_p_FIX__DerivativeSecurityExchangeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityExchange *) x));
}
static void *_p_FIX__RiskRestructuringTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskRestructuringType *) x));
}
static void *_p_FIX__RestructuringTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RestructuringType *) x));
}
static void *_p_FIX__RelationshipRiskRestructuringTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskRestructuringType *) x));
}
static void *_p_FIX__UnderlyingRestructuringTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingRestructuringType *) x));
}
static void *_p_FIX__DateOfBirthTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DateOfBirth *) x));
}
static void *_p_FIX__ExpireDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ExpireDate *) x));
}
static void *_p_FIX__BasisFeatureDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::BasisFeatureDate *) x));
}
static void *_p_FIX__CollRespIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CollRespID *) x));
}
static void *_p_FIX__RptSysTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RptSys *) x));
}
static void *_p_FIX__QuoteRespIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::QuoteRespID *) x));
}
static void *_p_FIX__RiskProductComplexTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskProductComplex *) x));
}
static void *_p_FIX__RelationshipRiskProductComplexTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskProductComplex *) x));
}
static void *_p_FIX__ProductComplexTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ProductComplex *) x));
}
static void *_p_FIX__DerivativeProductComplexTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeProductComplex *) x));
}
static void *_p_FIX__SettlObligIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlObligID *) x));
}
static void *_p_FIX__RegistIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RegistID *) x));
}
static void *_p_FIX__MiscFeeTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MiscFeeType *) x));
}
static void *_p_FIX__LegMaturityMonthYearTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegMaturityMonthYear *) x));
}
static void *_p_FIX__StartMaturityMonthYearTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::StartMaturityMonthYear *) x));
}
static void *_p_FIX__MaturityMonthYearTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MaturityMonthYear *) x));
}
static void *_p_FIX__DerivativeMaturityMonthYearTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeMaturityMonthYear *) x));
}
static void *_p_FIX__UnderlyingMaturityMonthYearTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingMaturityMonthYear *) x));
}
static void *_p_FIX__EndMaturityMonthYearTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EndMaturityMonthYear *) x));
}
static void *_p_FIX__UnderlyingLegMaturityMonthYearTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegMaturityMonthYear *) x));
}
static void *_p_FIX__RelationshipRiskMaturityMonthYearTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskMaturityMonthYear *) x));
}
static void *_p_FIX__RiskMaturityMonthYearTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskMaturityMonthYear *) x));
}
static void *_p_FIX__OrigPosReqRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::OrigPosReqRefID *) x));
}
static void *_p_FIX__PosMaintRptIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PosMaintRptID *) x));
}
static void *_p_FIX__ContIntRptIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ContIntRptID *) x));
}
static void *_p_FIX__SynchronizedApplicationTo_p_FIX__Application(void *x) {
    return (void *)((FIX::Application *)  ((FIX::SynchronizedApplication *) x));
}
static void *_p_FIX__NullApplicationTo_p_FIX__Application(void *x) {
    return (void *)((FIX::Application *)  ((FIX::NullApplication *) x));
}
static void *_p_FIX__SocketSendFailedTo_p_FIX__SocketException(void *x) {
    return (void *)((FIX::SocketException *)  ((FIX::SocketSendFailed *) x));
}
static void *_p_FIX__SocketRecvFailedTo_p_FIX__SocketException(void *x) {
    return (void *)((FIX::SocketException *)  ((FIX::SocketRecvFailed *) x));
}
static void *_p_FIX__SocketCloseFailedTo_p_FIX__SocketException(void *x) {
    return (void *)((FIX::SocketException *)  ((FIX::SocketCloseFailed *) x));
}
static void *_p_FIX__RequiredTagMissingTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::RequiredTagMissing *) x));
}
static void *_p_FIX__SocketSendFailedTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *) (FIX::SocketException *) ((FIX::SocketSendFailed *) x));
}
static void *_p_FIX__SocketRecvFailedTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *) (FIX::SocketException *) ((FIX::SocketRecvFailed *) x));
}
static void *_p_FIX__InvalidTagNumberTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::InvalidTagNumber *) x));
}
static void *_p_FIX__RejectLogonTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::RejectLogon *) x));
}
static void *_p_FIX__IncorrectDataFormatTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::IncorrectDataFormat *) x));
}
static void *_p_FIX__TagNotDefinedForMessageTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::TagNotDefinedForMessage *) x));
}
static void *_p_FIX__InvalidMessageTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::InvalidMessage *) x));
}
static void *_p_FIX__RuntimeErrorTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::RuntimeError *) x));
}
static void *_p_FIX__MessageParseErrorTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::MessageParseError *) x));
}
static void *_p_FIX__DuplicateFieldNumberTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::DuplicateFieldNumber *) x));
}
static void *_p_FIX__DoNotSendTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::DoNotSend *) x));
}
static void *_p_FIX__FieldNotFoundTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::FieldNotFound *) x));
}
static void *_p_FIX__DataDictionaryNotFoundTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::DataDictionaryNotFound *) x));
}
static void *_p_FIX__SessionNotFoundTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::SessionNotFound *) x));
}
static void *_p_FIX__IOExceptionTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::IOException *) x));
}
static void *_p_FIX__SocketExceptionTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::SocketException *) x));
}
static void *_p_FIX__ConfigErrorTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::ConfigError *) x));
}
static void *_p_FIX__InvalidMessageTypeTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::InvalidMessageType *) x));
}
static void *_p_FIX__UnsupportedMessageTypeTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::UnsupportedMessageType *) x));
}
static void *_p_FIX__UnsupportedVersionTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::UnsupportedVersion *) x));
}
static void *_p_FIX__IncorrectTagValueTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::IncorrectTagValue *) x));
}
static void *_p_FIX__NoTagValueTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::NoTagValue *) x));
}
static void *_p_FIX__TagOutOfOrderTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::TagOutOfOrder *) x));
}
static void *_p_FIX__RepeatedTagTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::RepeatedTag *) x));
}
static void *_p_FIX__SocketCloseFailedTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *) (FIX::SocketException *) ((FIX::SocketCloseFailed *) x));
}
static void *_p_FIX__FieldConvertErrorTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::FieldConvertError *) x));
}
static void *_p_FIX__IncorrectMessageStructureTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::IncorrectMessageStructure *) x));
}
static void *_p_FIX__RepeatingGroupCountMismatchTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::RepeatingGroupCountMismatch *) x));
}
static void *_p_FIX__NoNewsRefIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoNewsRefIDs *) x));
}
static void *_p_FIX__NoPositionsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoPositions *) x));
}
static void *_p_FIX__NoRelationshipRiskWarningLevelsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRelationshipRiskWarningLevels *) x));
}
static void *_p_FIX__MaxPriceLevelsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MaxPriceLevels *) x));
}
static void *_p_FIX__NoRiskWarningLevelsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRiskWarningLevels *) x));
}
static void *_p_FIX__NoMiscFeesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoMiscFees *) x));
}
static void *_p_FIX__ClearingInstructionTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ClearingInstruction *) x));
}
static void *_p_FIX__NoComplexEventTimesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoComplexEventTimes *) x));
}
static void *_p_FIX__RepurchaseTermTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RepurchaseTerm *) x));
}
static void *_p_FIX__LegRepurchaseTermTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LegRepurchaseTerm *) x));
}
static void *_p_FIX__UnderlyingRepurchaseTermTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingRepurchaseTerm *) x));
}
static void *_p_FIX__MDSecSizeTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MDSecSizeType *) x));
}
static void *_p_FIX__RptSeqTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RptSeq *) x));
}
static void *_p_FIX__NumBiddersTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NumBidders *) x));
}
static void *_p_FIX__MDPriceLevelTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MDPriceLevel *) x));
}
static void *_p_FIX__MultilegModelTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MultilegModel *) x));
}
static void *_p_FIX__QuoteResponseLevelTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteResponseLevel *) x));
}
static void *_p_FIX__ComplexEventConditionTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ComplexEventCondition *) x));
}
static void *_p_FIX__OptPayoutTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::OptPayoutType *) x));
}
static void *_p_FIX__SideValueIndTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SideValueInd *) x));
}
static void *_p_FIX__NoContAmtsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoContAmts *) x));
}
static void *_p_FIX__ContractMultiplierUnitTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ContractMultiplierUnit *) x));
}
static void *_p_FIX__LegContractMultiplierUnitTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LegContractMultiplierUnit *) x));
}
static void *_p_FIX__DerivativeContractMultiplierUnitTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeContractMultiplierUnit *) x));
}
static void *_p_FIX__NoRelationshipRiskInstrumentsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRelationshipRiskInstruments *) x));
}
static void *_p_FIX__UnderlyingContractMultiplierUnitTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingContractMultiplierUnit *) x));
}
static void *_p_FIX__NoRiskInstrumentsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRiskInstruments *) x));
}
static void *_p_FIX__ApplEndSeqNumTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ApplEndSeqNum *) x));
}
static void *_p_FIX__RefApplLastSeqNumTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RefApplLastSeqNum *) x));
}
static void *_p_FIX__ApplLastSeqNumTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ApplLastSeqNum *) x));
}
static void *_p_FIX__RefSeqNumTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RefSeqNum *) x));
}
static void *_p_FIX__ApplSeqNumTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ApplSeqNum *) x));
}
static void *_p_FIX__ApplNewSeqNumTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ApplNewSeqNum *) x));
}
static void *_p_FIX__NextExpectedMsgSeqNumTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NextExpectedMsgSeqNum *) x));
}
static void *_p_FIX__MsgSeqNumTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MsgSeqNum *) x));
}
static void *_p_FIX__ApplBegSeqNumTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ApplBegSeqNum *) x));
}
static void *_p_FIX__NoExecInstRulesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoExecInstRules *) x));
}
static void *_p_FIX__TotNoQuoteEntriesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoQuoteEntries *) x));
}
static void *_p_FIX__NoMDEntriesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoMDEntries *) x));
}
static void *_p_FIX__TotQuoteEntriesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotQuoteEntries *) x));
}
static void *_p_FIX__NoQuoteEntriesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoQuoteEntries *) x));
}
static void *_p_FIX__HopRefIDTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::HopRefID *) x));
}
static void *_p_FIX__SessionRejectReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SessionRejectReason *) x));
}
static void *_p_FIX__ListRejectReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ListRejectReason *) x));
}
static void *_p_FIX__MassActionRejectReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MassActionRejectReason *) x));
}
static void *_p_FIX__ConfirmRejReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ConfirmRejReason *) x));
}
static void *_p_FIX__CxlRejReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CxlRejReason *) x));
}
static void *_p_FIX__StreamAsgnRejReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::StreamAsgnRejReason *) x));
}
static void *_p_FIX__QuoteEntryRejectReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteEntryRejectReason *) x));
}
static void *_p_FIX__OrdRejReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::OrdRejReason *) x));
}
static void *_p_FIX__ExecRestatementReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ExecRestatementReason *) x));
}
static void *_p_FIX__TradeReportRejectReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TradeReportRejectReason *) x));
}
static void *_p_FIX__QuoteRejectReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteRejectReason *) x));
}
static void *_p_FIX__CollAsgnReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CollAsgnReason *) x));
}
static void *_p_FIX__MassCancelRejectReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MassCancelRejectReason *) x));
}
static void *_p_FIX__TradSesStatusRejReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TradSesStatusRejReason *) x));
}
static void *_p_FIX__QuoteRequestRejectReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteRequestRejectReason *) x));
}
static void *_p_FIX__CollAsgnRejectReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CollAsgnRejectReason *) x));
}
static void *_p_FIX__NoContraBrokersTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoContraBrokers *) x));
}
static void *_p_FIX__RefOrdIDReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RefOrdIDReason *) x));
}
static void *_p_FIX__BusinessRejectReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::BusinessRejectReason *) x));
}
static void *_p_FIX__AllocCancReplaceReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AllocCancReplaceReason *) x));
}
static void *_p_FIX__ShortSaleReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ShortSaleReason *) x));
}
static void *_p_FIX__SettlementCycleNoTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SettlementCycleNo *) x));
}
static void *_p_FIX__NoTrdRegTimestampsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoTrdRegTimestamps *) x));
}
static void *_p_FIX__NoAffectedOrdersTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoAffectedOrders *) x));
}
static void *_p_FIX__TotalAffectedOrdersTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotalAffectedOrders *) x));
}
static void *_p_FIX__NoNotAffectedOrdersTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoNotAffectedOrders *) x));
}
static void *_p_FIX__NumberOfOrdersTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NumberOfOrders *) x));
}
static void *_p_FIX__TotNoOrdersTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoOrders *) x));
}
static void *_p_FIX__NoOrdersTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoOrders *) x));
}
static void *_p_FIX__NoApplIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoApplIDs *) x));
}
static void *_p_FIX__ApplQueueResolutionTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ApplQueueResolution *) x));
}
static void *_p_FIX__AvgPrxPrecisionTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AvgPrxPrecision *) x));
}
static void *_p_FIX__AvgPxPrecisionTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AvgPxPrecision *) x));
}
static void *_p_FIX__AdjustmentTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::Adjustment *) x));
}
static void *_p_FIX__MiscFeeBasisTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MiscFeeBasis *) x));
}
static void *_p_FIX__RegistRejReasonCodeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RegistRejReasonCode *) x));
}
static void *_p_FIX__ListStatusTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ListStatusType *) x));
}
static void *_p_FIX__NoQuoteSetsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoQuoteSets *) x));
}
static void *_p_FIX__ExpTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ExpType *) x));
}
static void *_p_FIX__EncodedIssuerLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedIssuerLen *) x));
}
static void *_p_FIX__EncodedLegIssuerLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedLegIssuerLen *) x));
}
static void *_p_FIX__EncodedUnderlyingIssuerLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedUnderlyingIssuerLen *) x));
}
static void *_p_FIX__DerivativeEncodedIssuerLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeEncodedIssuerLen *) x));
}
static void *_p_FIX__DeliveryFormTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DeliveryForm *) x));
}
static void *_p_FIX__PegLimitTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PegLimitType *) x));
}
static void *_p_FIX__DiscretionLimitTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DiscretionLimitType *) x));
}
static void *_p_FIX__SecondaryPriceLimitTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SecondaryPriceLimitType *) x));
}
static void *_p_FIX__RelationshipRiskLimitTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RelationshipRiskLimitType *) x));
}
static void *_p_FIX__RiskLimitTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RiskLimitType *) x));
}
static void *_p_FIX__PriceLimitTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PriceLimitType *) x));
}
static void *_p_FIX__RelationshipRiskInstrumentOperatorTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RelationshipRiskInstrumentOperator *) x));
}
static void *_p_FIX__RiskInstrumentOperatorTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RiskInstrumentOperator *) x));
}
static void *_p_FIX__RelationshipRiskProductTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RelationshipRiskProduct *) x));
}
static void *_p_FIX__RiskProductTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RiskProduct *) x));
}
static void *_p_FIX__LegProductTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LegProduct *) x));
}
static void *_p_FIX__NoTradingSessionsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoTradingSessions *) x));
}
static void *_p_FIX__NoCapacitiesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoCapacities *) x));
}
static void *_p_FIX__DerivativeProductTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeProduct *) x));
}
static void *_p_FIX__UnderlyingProductTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingProduct *) x));
}
static void *_p_FIX__ProductTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::Product *) x));
}
static void *_p_FIX__IncTaxIndTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::IncTaxInd *) x));
}
static void *_p_FIX__UnderlyingSettlPriceTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingSettlPriceType *) x));
}
static void *_p_FIX__PegPriceTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PegPriceType *) x));
}
static void *_p_FIX__PriceTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PriceType *) x));
}
static void *_p_FIX__YieldRedemptionPriceTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::YieldRedemptionPriceType *) x));
}
static void *_p_FIX__QuotePriceTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::QuotePriceType *) x));
}
static void *_p_FIX__LegBenchmarkPriceTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LegBenchmarkPriceType *) x));
}
static void *_p_FIX__SettlPriceTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SettlPriceType *) x));
}
static void *_p_FIX__TrdRegTimestampTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TrdRegTimestampType *) x));
}
static void *_p_FIX__SideTrdRegTimestampTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SideTrdRegTimestampType *) x));
}
static void *_p_FIX__LegPriceTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LegPriceType *) x));
}
static void *_p_FIX__BenchmarkPriceTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::BenchmarkPriceType *) x));
}
static void *_p_FIX__RateSourceTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RateSourceType *) x));
}
static void *_p_FIX__MassActionTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MassActionType *) x));
}
static void *_p_FIX__TerminationTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TerminationType *) x));
}
static void *_p_FIX__NoSecurityAltIDTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoSecurityAltID *) x));
}
static void *_p_FIX__NoUnderlyingSecurityAltIDTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoUnderlyingSecurityAltID *) x));
}
static void *_p_FIX__NoDerivativeSecurityAltIDTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoDerivativeSecurityAltID *) x));
}
static void *_p_FIX__NoRelationshipRiskSecurityAltIDTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRelationshipRiskSecurityAltID *) x));
}
static void *_p_FIX__NoUnderlyingLegSecurityAltIDTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoUnderlyingLegSecurityAltID *) x));
}
static void *_p_FIX__NoRiskSecurityAltIDTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRiskSecurityAltID *) x));
}
static void *_p_FIX__NoAsgnReqsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoAsgnReqs *) x));
}
static void *_p_FIX__NoMatchRulesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoMatchRules *) x));
}
static void *_p_FIX__DerivativeSecurityListRequestTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeSecurityListRequestType *) x));
}
static void *_p_FIX__SecurityRequestTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityRequestType *) x));
}
static void *_p_FIX__TradeRequestTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TradeRequestType *) x));
}
static void *_p_FIX__UserRequestTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UserRequestType *) x));
}
static void *_p_FIX__NetworkRequestTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NetworkRequestType *) x));
}
static void *_p_FIX__SecurityListTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityListType *) x));
}
static void *_p_FIX__QuoteRequestTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteRequestType *) x));
}
static void *_p_FIX__SecurityListRequestTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityListRequestType *) x));
}
static void *_p_FIX__HeartBtIntTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::HeartBtInt *) x));
}
static void *_p_FIX__StatsTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::StatsType *) x));
}
static void *_p_FIX__AllocSettlInstTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AllocSettlInstType *) x));
}
static void *_p_FIX__RiskPutOrCallTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RiskPutOrCall *) x));
}
static void *_p_FIX__LegPutOrCallTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LegPutOrCall *) x));
}
static void *_p_FIX__UnderlyingLegPutOrCallTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingLegPutOrCall *) x));
}
static void *_p_FIX__DerivativePutOrCallTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativePutOrCall *) x));
}
static void *_p_FIX__PutOrCallTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PutOrCall *) x));
}
static void *_p_FIX__RelationshipRiskPutOrCallTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RelationshipRiskPutOrCall *) x));
}
static void *_p_FIX__UnderlyingPutOrCallTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingPutOrCall *) x));
}
static void *_p_FIX__ComplexEventPriceTimeTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ComplexEventPriceTimeType *) x));
}
static void *_p_FIX__LiquidityIndTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LiquidityIndType *) x));
}
static void *_p_FIX__ContingencyTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ContingencyType *) x));
}
static void *_p_FIX__TradePublishIndicatorTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TradePublishIndicator *) x));
}
static void *_p_FIX__ImpliedMarketIndicatorTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ImpliedMarketIndicator *) x));
}
static void *_p_FIX__AvgPxIndicatorTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AvgPxIndicator *) x));
}
static void *_p_FIX__ListOrderStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ListOrderStatus *) x));
}
static void *_p_FIX__TradeRequestStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TradeRequestStatus *) x));
}
static void *_p_FIX__SessionStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SessionStatus *) x));
}
static void *_p_FIX__SecDefStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SecDefStatus *) x));
}
static void *_p_FIX__StrikeExerciseStyleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::StrikeExerciseStyle *) x));
}
static void *_p_FIX__TradeAllocIndicatorTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TradeAllocIndicator *) x));
}
static void *_p_FIX__UserStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UserStatus *) x));
}
static void *_p_FIX__TrdRptStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TrdRptStatus *) x));
}
static void *_p_FIX__ExerciseStyleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ExerciseStyle *) x));
}
static void *_p_FIX__CollStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CollStatus *) x));
}
static void *_p_FIX__LegExerciseStyleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LegExerciseStyle *) x));
}
static void *_p_FIX__PosMaintStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PosMaintStatus *) x));
}
static void *_p_FIX__PriorityIndicatorTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PriorityIndicator *) x));
}
static void *_p_FIX__UnderlyingExerciseStyleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingExerciseStyle *) x));
}
static void *_p_FIX__CustOrderCapacityTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CustOrderCapacity *) x));
}
static void *_p_FIX__OrigCustOrderCapacityTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::OrigCustOrderCapacity *) x));
}
static void *_p_FIX__NoComplexEventDatesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoComplexEventDates *) x));
}
static void *_p_FIX__QuoteEntryStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteEntryStatus *) x));
}
static void *_p_FIX__CollInquiryStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CollInquiryStatus *) x));
}
static void *_p_FIX__TradSesStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TradSesStatus *) x));
}
static void *_p_FIX__QuoteAckStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteAckStatus *) x));
}
static void *_p_FIX__AffirmStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AffirmStatus *) x));
}
static void *_p_FIX__PosQtyStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PosQtyStatus *) x));
}
static void *_p_FIX__QuoteStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteStatus *) x));
}
static void *_p_FIX__ConfirmStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ConfirmStatus *) x));
}
static void *_p_FIX__AllocTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AllocType *) x));
}
static void *_p_FIX__IndividualAllocTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::IndividualAllocType *) x));
}
static void *_p_FIX__NoSettlInstTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoSettlInst *) x));
}
static void *_p_FIX__SecurityTradingStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityTradingStatus *) x));
}
static void *_p_FIX__AllocStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AllocStatus *) x));
}
static void *_p_FIX__PosReqStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PosReqStatus *) x));
}
static void *_p_FIX__ListSeqNoTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ListSeqNo *) x));
}
static void *_p_FIX__MaxMessageSizeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MaxMessageSize *) x));
}
static void *_p_FIX__MarketDepthTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MarketDepth *) x));
}
static void *_p_FIX__NoPartyRelationshipsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoPartyRelationships *) x));
}
static void *_p_FIX__ApplResponseErrorTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ApplResponseError *) x));
}
static void *_p_FIX__CollApplTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CollApplType *) x));
}
static void *_p_FIX__GTBookingInstTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::GTBookingInst *) x));
}
static void *_p_FIX__NumTicketsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NumTickets *) x));
}
static void *_p_FIX__LegSwapTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LegSwapType *) x));
}
static void *_p_FIX__OrderDelayTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::OrderDelay *) x));
}
static void *_p_FIX__NoTradesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoTrades *) x));
}
static void *_p_FIX__SecurityXMLLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityXMLLen *) x));
}
static void *_p_FIX__DerivativeSecurityXMLLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeSecurityXMLLen *) x));
}
static void *_p_FIX__MaturityMonthYearFormatTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MaturityMonthYearFormat *) x));
}
static void *_p_FIX__QuoteCancelTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteCancelType *) x));
}
static void *_p_FIX__ModelTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ModelType *) x));
}
static void *_p_FIX__NoHopsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoHops *) x));
}
static void *_p_FIX__ResponseTransportTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ResponseTransportType *) x));
}
static void *_p_FIX__TradeReportTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TradeReportType *) x));
}
static void *_p_FIX__AllocReportTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AllocReportType *) x));
}
static void *_p_FIX__ApplReportTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ApplReportType *) x));
}
static void *_p_FIX__MultiLegRptTypeReqTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MultiLegRptTypeReq *) x));
}
static void *_p_FIX__CrossTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CrossType *) x));
}
static void *_p_FIX__FlowScheduleTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::FlowScheduleType *) x));
}
static void *_p_FIX__LegFlowScheduleTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LegFlowScheduleType *) x));
}
static void *_p_FIX__DerivativeFlowScheduleTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeFlowScheduleType *) x));
}
static void *_p_FIX__UnderlyingFlowScheduleTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingFlowScheduleType *) x));
}
static void *_p_FIX__TickRuleTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TickRuleType *) x));
}
static void *_p_FIX__NoRateSourcesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRateSources *) x));
}
static void *_p_FIX__NestedPartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NestedPartyRole *) x));
}
static void *_p_FIX__RelatedPartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RelatedPartyRole *) x));
}
static void *_p_FIX__PartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PartyRole *) x));
}
static void *_p_FIX__DerivativeInstrumentPartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeInstrumentPartyRole *) x));
}
static void *_p_FIX__Nested3PartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::Nested3PartyRole *) x));
}
static void *_p_FIX__RelatedContextPartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RelatedContextPartyRole *) x));
}
static void *_p_FIX__SettlPartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SettlPartyRole *) x));
}
static void *_p_FIX__Nested4PartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::Nested4PartyRole *) x));
}
static void *_p_FIX__RequestedPartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RequestedPartyRole *) x));
}
static void *_p_FIX__InstrumentPartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::InstrumentPartyRole *) x));
}
static void *_p_FIX__TrdRepPartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TrdRepPartyRole *) x));
}
static void *_p_FIX__ContextPartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ContextPartyRole *) x));
}
static void *_p_FIX__RootPartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RootPartyRole *) x));
}
static void *_p_FIX__UndlyInstrumentPartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UndlyInstrumentPartyRole *) x));
}
static void *_p_FIX__Nested2PartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::Nested2PartyRole *) x));
}
static void *_p_FIX__TargetPartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TargetPartyRole *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingInstrumentPartyRole *) x));
}
static void *_p_FIX__EncodedUnderlyingSecurityDescLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedUnderlyingSecurityDescLen *) x));
}
static void *_p_FIX__EncodedLegSecurityDescLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedLegSecurityDescLen *) x));
}
static void *_p_FIX__DerivativeEncodedSecurityDescLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeEncodedSecurityDescLen *) x));
}
static void *_p_FIX__RelationshipRiskEncodedSecurityDescLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RelationshipRiskEncodedSecurityDescLen *) x));
}
static void *_p_FIX__EncodedMktSegmDescLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedMktSegmDescLen *) x));
}
static void *_p_FIX__EncodedSecurityListDescLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedSecurityListDescLen *) x));
}
static void *_p_FIX__EncodedSecurityDescLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedSecurityDescLen *) x));
}
static void *_p_FIX__RiskEncodedSecurityDescLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RiskEncodedSecurityDescLen *) x));
}
static void *_p_FIX__SettlObligModeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SettlObligMode *) x));
}
static void *_p_FIX__LegNumberTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LegNumber *) x));
}
static void *_p_FIX__StatusValueTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::StatusValue *) x));
}
static void *_p_FIX__SideQtyTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SideQty *) x));
}
static void *_p_FIX__SideLiquidityIndTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SideLiquidityInd *) x));
}
static void *_p_FIX__LastLiquidityIndTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LastLiquidityInd *) x));
}
static void *_p_FIX__FillLiquidityIndTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::FillLiquidityInd *) x));
}
static void *_p_FIX__NoCollInquiryQualifierTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoCollInquiryQualifier *) x));
}
static void *_p_FIX__CollInquiryQualifierTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CollInquiryQualifier *) x));
}
static void *_p_FIX__StandInstDbTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::StandInstDbType *) x));
}
static void *_p_FIX__NoMarketSegmentsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoMarketSegments *) x));
}
static void *_p_FIX__TargetStrategyTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TargetStrategy *) x));
}
static void *_p_FIX__NoRelatedPartyAltSubIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRelatedPartyAltSubIDs *) x));
}
static void *_p_FIX__NoPartyAltSubIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoPartyAltSubIDs *) x));
}
static void *_p_FIX__NoPartySubIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoPartySubIDs *) x));
}
static void *_p_FIX__NoInstrumentPartySubIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoInstrumentPartySubIDs *) x));
}
static void *_p_FIX__NoContextPartySubIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoContextPartySubIDs *) x));
}
static void *_p_FIX__NoRelatedPartySubIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRelatedPartySubIDs *) x));
}
static void *_p_FIX__NoSettlPartySubIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoSettlPartySubIDs *) x));
}
static void *_p_FIX__NoDerivativeInstrumentPartySubIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoDerivativeInstrumentPartySubIDs *) x));
}
static void *_p_FIX__NoNested3PartySubIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoNested3PartySubIDs *) x));
}
static void *_p_FIX__NoNested4PartySubIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoNested4PartySubIDs *) x));
}
static void *_p_FIX__NoNestedPartySubIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoNestedPartySubIDs *) x));
}
static void *_p_FIX__NoRootPartySubIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRootPartySubIDs *) x));
}
static void *_p_FIX__NoNested2PartySubIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoNested2PartySubIDs *) x));
}
static void *_p_FIX__NoRelatedContextPartySubIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRelatedContextPartySubIDs *) x));
}
static void *_p_FIX__NoUndlyInstrumentPartySubIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoUndlyInstrumentPartySubIDs *) x));
}
static void *_p_FIX__DiscretionMoveTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DiscretionMoveType *) x));
}
static void *_p_FIX__PegMoveTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PegMoveType *) x));
}
static void *_p_FIX__NoPosAmtTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoPosAmt *) x));
}
static void *_p_FIX__AllocNoOrdersTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AllocNoOrdersType *) x));
}
static void *_p_FIX__ListNoOrdsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ListNoOrds *) x));
}
static void *_p_FIX__NoSideTrdRegTSTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoSideTrdRegTS *) x));
}
static void *_p_FIX__TotNoFillsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoFills *) x));
}
static void *_p_FIX__NoFillsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoFills *) x));
}
static void *_p_FIX__EncodedListExecInstLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedListExecInstLen *) x));
}
static void *_p_FIX__EncodedHeadlineLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedHeadlineLen *) x));
}
static void *_p_FIX__SellerDaysTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SellerDays *) x));
}
static void *_p_FIX__UnderlyingPriceDeterminationMethodTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingPriceDeterminationMethod *) x));
}
static void *_p_FIX__PaymentMethodTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PaymentMethod *) x));
}
static void *_p_FIX__StrikePriceDeterminationMethodTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::StrikePriceDeterminationMethod *) x));
}
static void *_p_FIX__EncryptMethodTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncryptMethod *) x));
}
static void *_p_FIX__ListMethodTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ListMethod *) x));
}
static void *_p_FIX__DistribPaymentMethodTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DistribPaymentMethod *) x));
}
static void *_p_FIX__EncryptedPasswordMethodTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncryptedPasswordMethod *) x));
}
static void *_p_FIX__DerivativeListMethodTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeListMethod *) x));
}
static void *_p_FIX__StrikePriceBoundaryMethodTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::StrikePriceBoundaryMethod *) x));
}
static void *_p_FIX__MultilegPriceMethodTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MultilegPriceMethod *) x));
}
static void *_p_FIX__ComplexEventPriceBoundaryMethodTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ComplexEventPriceBoundaryMethod *) x));
}
static void *_p_FIX__AllocMethodTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AllocMethod *) x));
}
static void *_p_FIX__LastMsgSeqNumProcessedTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LastMsgSeqNumProcessed *) x));
}
static void *_p_FIX__TradSesMethodTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TradSesMethod *) x));
}
static void *_p_FIX__SettlInstReqRejCodeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SettlInstReqRejCode *) x));
}
static void *_p_FIX__AllocRejCodeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AllocRejCode *) x));
}
static void *_p_FIX__NoRegistDtlsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRegistDtls *) x));
}
static void *_p_FIX__IndividualAllocRejCodeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::IndividualAllocRejCode *) x));
}
static void *_p_FIX__TotNoAllocsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoAllocs *) x));
}
static void *_p_FIX__NoLegAllocsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoLegAllocs *) x));
}
static void *_p_FIX__NoAllocsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoAllocs *) x));
}
static void *_p_FIX__NoMsgTypesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoMsgTypes *) x));
}
static void *_p_FIX__MDBookTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MDBookType *) x));
}
static void *_p_FIX__MDSubBookTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MDSubBookType *) x));
}
static void *_p_FIX__NoInstrAttribTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoInstrAttrib *) x));
}
static void *_p_FIX__NoNestedInstrAttribTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoNestedInstrAttrib *) x));
}
static void *_p_FIX__NoDerivativeInstrAttribTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoDerivativeInstrAttrib *) x));
}
static void *_p_FIX__NoUnderlyingsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoUnderlyings *) x));
}
static void *_p_FIX__NoOfLegUnderlyingsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoOfLegUnderlyings *) x));
}
static void *_p_FIX__NoCompIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoCompIDs *) x));
}
static void *_p_FIX__NoStrikeRulesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoStrikeRules *) x));
}
static void *_p_FIX__NoTimeInForceRulesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoTimeInForceRules *) x));
}
static void *_p_FIX__NoLotTypeRulesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoLotTypeRules *) x));
}
static void *_p_FIX__NoOrdTypeRulesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoOrdTypeRules *) x));
}
static void *_p_FIX__NoExpirationTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoExpiration *) x));
}
static void *_p_FIX__NoUndlyInstrumentPartiesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoUndlyInstrumentParties *) x));
}
static void *_p_FIX__NoDerivativeInstrumentPartiesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoDerivativeInstrumentParties *) x));
}
static void *_p_FIX__NoInstrumentPartiesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoInstrumentParties *) x));
}
static void *_p_FIX__EncryptedNewPasswordLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncryptedNewPasswordLen *) x));
}
static void *_p_FIX__EncryptedPasswordLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncryptedPasswordLen *) x));
}
static void *_p_FIX__NoNested4PartyIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoNested4PartyIDs *) x));
}
static void *_p_FIX__NoContextPartyIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoContextPartyIDs *) x));
}
static void *_p_FIX__NoNestedPartyIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoNestedPartyIDs *) x));
}
static void *_p_FIX__NoNested2PartyIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoNested2PartyIDs *) x));
}
static void *_p_FIX__NoRelatedPartyIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRelatedPartyIDs *) x));
}
static void *_p_FIX__NoSettlPartyIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoSettlPartyIDs *) x));
}
static void *_p_FIX__NoTargetPartyIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoTargetPartyIDs *) x));
}
static void *_p_FIX__NoRootPartyIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRootPartyIDs *) x));
}
static void *_p_FIX__NoLegsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoLegs *) x));
}
static void *_p_FIX__NoPartyIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoPartyIDs *) x));
}
static void *_p_FIX__NoNested3PartyIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoNested3PartyIDs *) x));
}
static void *_p_FIX__NoRelatedContextPartyIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRelatedContextPartyIDs *) x));
}
static void *_p_FIX__NoStrategyParametersTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoStrategyParameters *) x));
}
static void *_p_FIX__NoPartyListTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoPartyList *) x));
}
static void *_p_FIX__TotNoPartyListTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoPartyList *) x));
}
static void *_p_FIX__PegRoundDirectionTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PegRoundDirection *) x));
}
static void *_p_FIX__DiscretionRoundDirectionTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DiscretionRoundDirection *) x));
}
static void *_p_FIX__SideTrdSubTypTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SideTrdSubTyp *) x));
}
static void *_p_FIX__NoBidComponentsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoBidComponents *) x));
}
static void *_p_FIX__NoSettlObligTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoSettlOblig *) x));
}
static void *_p_FIX__PegOffsetTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PegOffsetType *) x));
}
static void *_p_FIX__DiscretionOffsetTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DiscretionOffsetType *) x));
}
static void *_p_FIX__CustomerOrFirmTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CustomerOrFirm *) x));
}
static void *_p_FIX__TradSesModeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TradSesMode *) x));
}
static void *_p_FIX__PegScopeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PegScope *) x));
}
static void *_p_FIX__SecurityReportIDTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityReportID *) x));
}
static void *_p_FIX__MDReportIDTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MDReportID *) x));
}
static void *_p_FIX__AllocLinkTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AllocLinkType *) x));
}
static void *_p_FIX__NoUnderlyingAmountsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoUnderlyingAmounts *) x));
}
static void *_p_FIX__NoClearingInstructionsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoClearingInstructions *) x));
}
static void *_p_FIX__MDQuoteTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MDQuoteType *) x));
}
static void *_p_FIX__MDUpdateTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MDUpdateType *) x));
}
static void *_p_FIX__QuoteTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteType *) x));
}
static void *_p_FIX__StreamAsgnAckTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::StreamAsgnAckType *) x));
}
static void *_p_FIX__QuoteRespTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteRespType *) x));
}
static void *_p_FIX__CollAsgnRespTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CollAsgnRespType *) x));
}
static void *_p_FIX__NoMaturityRulesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoMaturityRules *) x));
}
static void *_p_FIX__SideLastQtyTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SideLastQty *) x));
}
static void *_p_FIX__TotNumReportsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotNumReports *) x));
}
static void *_p_FIX__TotNumAssignmentReportsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotNumAssignmentReports *) x));
}
static void *_p_FIX__TotalNumPosReportsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotalNumPosReports *) x));
}
static void *_p_FIX__TotNumTradeReportsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotNumTradeReports *) x));
}
static void *_p_FIX__XmlDataLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::XmlDataLen *) x));
}
static void *_p_FIX__SecureDataLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SecureDataLen *) x));
}
static void *_p_FIX__CoveredOrUncoveredTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CoveredOrUncovered *) x));
}
static void *_p_FIX__LegCoveredOrUncoveredTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LegCoveredOrUncovered *) x));
}
static void *_p_FIX__NoRequestedPartyRolesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRequestedPartyRoles *) x));
}
static void *_p_FIX__NoTradingSessionRulesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoTradingSessionRules *) x));
}
static void *_p_FIX__TradSesEventTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TradSesEvent *) x));
}
static void *_p_FIX__RepoCollateralSecurityTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RepoCollateralSecurityType *) x));
}
static void *_p_FIX__LegRepoCollateralSecurityTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LegRepoCollateralSecurityType *) x));
}
static void *_p_FIX__ExpirationQtyTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ExpirationQtyType *) x));
}
static void *_p_FIX__QtyTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::QtyType *) x));
}
static void *_p_FIX__QuantityTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::QuantityType *) x));
}
static void *_p_FIX__UnderlyingRepoCollateralSecurityTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingRepoCollateralSecurityType *) x));
}
static void *_p_FIX__NoPartyListResponseTypesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoPartyListResponseTypes *) x));
}
static void *_p_FIX__NoSettlDetailsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoSettlDetails *) x));
}
static void *_p_FIX__CPProgramTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CPProgram *) x));
}
static void *_p_FIX__ApplTotalMessageCountTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ApplTotalMessageCount *) x));
}
static void *_p_FIX__MaturityMonthYearIncrementTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MaturityMonthYearIncrement *) x));
}
static void *_p_FIX__SecurityResponseTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityResponseType *) x));
}
static void *_p_FIX__ApplResponseTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ApplResponseType *) x));
}
static void *_p_FIX__ApplQueueDepthTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ApplQueueDepth *) x));
}
static void *_p_FIX__PartyListResponseTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PartyListResponseType *) x));
}
static void *_p_FIX__NetworkStatusResponseTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NetworkStatusResponseType *) x));
}
static void *_p_FIX__NoComplexEventsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoComplexEvents *) x));
}
static void *_p_FIX__ComplexEventTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ComplexEventType *) x));
}
static void *_p_FIX__AllocAccountTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AllocAccountType *) x));
}
static void *_p_FIX__RespondentTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RespondentType *) x));
}
static void *_p_FIX__AccountTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AccountType *) x));
}
static void *_p_FIX__AdjustmentTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AdjustmentType *) x));
}
static void *_p_FIX__DerivativeEventTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeEventType *) x));
}
static void *_p_FIX__NoEventsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoEvents *) x));
}
static void *_p_FIX__NoDerivativeEventsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoDerivativeEvents *) x));
}
static void *_p_FIX__EventTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EventType *) x));
}
static void *_p_FIX__UnderlyingSettlementTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingSettlementType *) x));
}
static void *_p_FIX__NoAltMDSourceTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoAltMDSource *) x));
}
static void *_p_FIX__AcctIDSourceTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AcctIDSource *) x));
}
static void *_p_FIX__OrderHandlingInstSourceTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::OrderHandlingInstSource *) x));
}
static void *_p_FIX__AllocAcctIDSourceTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AllocAcctIDSource *) x));
}
static void *_p_FIX__SecurityListTypeSourceTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityListTypeSource *) x));
}
static void *_p_FIX__RateSourceTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RateSource *) x));
}
static void *_p_FIX__DeskTypeSourceTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DeskTypeSource *) x));
}
static void *_p_FIX__BidTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::BidType *) x));
}
static void *_p_FIX__NoDatesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoDates *) x));
}
static void *_p_FIX__StrategyParameterTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::StrategyParameterType *) x));
}
static void *_p_FIX__OwnerTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::OwnerType *) x));
}
static void *_p_FIX__NoSidesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoSides *) x));
}
static void *_p_FIX__DerivativeNTPositionLimitTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeNTPositionLimit *) x));
}
static void *_p_FIX__MDOriginTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MDOriginType *) x));
}
static void *_p_FIX__PositionLimitTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PositionLimit *) x));
}
static void *_p_FIX__NTPositionLimitTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NTPositionLimit *) x));
}
static void *_p_FIX__CrossPrioritizationTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CrossPrioritization *) x));
}
static void *_p_FIX__DerivativePositionLimitTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativePositionLimit *) x));
}
static void *_p_FIX__TotNoRejQuotesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoRejQuotes *) x));
}
static void *_p_FIX__TotNoCxldQuotesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoCxldQuotes *) x));
}
static void *_p_FIX__AllocHandlInstTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AllocHandlInst *) x));
}
static void *_p_FIX__NoMDFeedTypesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoMDFeedTypes *) x));
}
static void *_p_FIX__TotNoAccQuotesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoAccQuotes *) x));
}
static void *_p_FIX__NoBidDescriptorsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoBidDescriptors *) x));
}
static void *_p_FIX__NoTrdRepIndicatorsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoTrdRepIndicators *) x));
}
static void *_p_FIX__NoStatsIndicatorsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoStatsIndicators *) x));
}
static void *_p_FIX__NoLegStipulationsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoLegStipulations *) x));
}
static void *_p_FIX__NoStipulationsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoStipulations *) x));
}
static void *_p_FIX__NoDistribInstsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoDistribInsts *) x));
}
static void *_p_FIX__TotalNumSecuritiesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotalNumSecurities *) x));
}
static void *_p_FIX__LiquidityNumSecuritiesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LiquidityNumSecurities *) x));
}
static void *_p_FIX__OrderDelayUnitTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::OrderDelayUnit *) x));
}
static void *_p_FIX__EndSeqNoTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EndSeqNo *) x));
}
static void *_p_FIX__NoRptsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRpts *) x));
}
static void *_p_FIX__SecurityTradingEventTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityTradingEvent *) x));
}
static void *_p_FIX__TrdSubTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TrdSubType *) x));
}
static void *_p_FIX__ProgRptReqsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ProgRptReqs *) x));
}
static void *_p_FIX__TotalNumSecurityTypesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotalNumSecurityTypes *) x));
}
static void *_p_FIX__NoMDEntryTypesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoMDEntryTypes *) x));
}
static void *_p_FIX__ProgPeriodIntervalTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ProgPeriodInterval *) x));
}
static void *_p_FIX__TotNoSecurityTypesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoSecurityTypes *) x));
}
static void *_p_FIX__NoSecurityTypesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoSecurityTypes *) x));
}
static void *_p_FIX__ContAmtTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ContAmtType *) x));
}
static void *_p_FIX__CollAsgnTransTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CollAsgnTransType *) x));
}
static void *_p_FIX__TradeReportTransTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TradeReportTransType *) x));
}
static void *_p_FIX__MassActionResponseTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MassActionResponse *) x));
}
static void *_p_FIX__ConfirmTransTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ConfirmTransType *) x));
}
static void *_p_FIX__PosTransTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PosTransType *) x));
}
static void *_p_FIX__BidDescriptorTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::BidDescriptorType *) x));
}
static void *_p_FIX__TaxAdvantageTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TaxAdvantageType *) x));
}
static void *_p_FIX__Nested2PartySubIDTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::Nested2PartySubIDType *) x));
}
static void *_p_FIX__UndlyInstrumentPartySubIDTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UndlyInstrumentPartySubIDType *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartySubIDTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingInstrumentPartySubIDType *) x));
}
static void *_p_FIX__RelatedPartySubIDTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RelatedPartySubIDType *) x));
}
static void *_p_FIX__PartyAltSubIDTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PartyAltSubIDType *) x));
}
static void *_p_FIX__NestedPartySubIDTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NestedPartySubIDType *) x));
}
static void *_p_FIX__Nested3PartySubIDTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::Nested3PartySubIDType *) x));
}
static void *_p_FIX__RelatedPartyAltSubIDTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RelatedPartyAltSubIDType *) x));
}
static void *_p_FIX__SettlPartySubIDTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SettlPartySubIDType *) x));
}
static void *_p_FIX__Nested4PartySubIDTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::Nested4PartySubIDType *) x));
}
static void *_p_FIX__NoRiskLimitsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRiskLimits *) x));
}
static void *_p_FIX__NoRelationshipRiskLimitsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRelationshipRiskLimits *) x));
}
static void *_p_FIX__NoDlvyInstTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoDlvyInst *) x));
}
static void *_p_FIX__DerivativeInstrumentPartySubIDTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeInstrumentPartySubIDType *) x));
}
static void *_p_FIX__RootPartySubIDTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RootPartySubIDType *) x));
}
static void *_p_FIX__InstrumentPartySubIDTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::InstrumentPartySubIDType *) x));
}
static void *_p_FIX__PartySubIDTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PartySubIDType *) x));
}
static void *_p_FIX__ContextPartySubIDTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ContextPartySubIDType *) x));
}
static void *_p_FIX__RelatedContextPartySubIDTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RelatedContextPartySubIDType *) x));
}
static void *_p_FIX__EncodedTextLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedTextLen *) x));
}
static void *_p_FIX__EncodedAllocTextLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedAllocTextLen *) x));
}
static void *_p_FIX__EncodedListStatusTextLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedListStatusTextLen *) x));
}
static void *_p_FIX__NoQuoteQualifiersTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoQuoteQualifiers *) x));
}
static void *_p_FIX__NoIOIQualifiersTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoIOIQualifiers *) x));
}
static void *_p_FIX__MDEntryPositionNoTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MDEntryPositionNo *) x));
}
static void *_p_FIX__BeginSeqNoTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::BeginSeqNo *) x));
}
static void *_p_FIX__MassStatusReqTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MassStatusReqType *) x));
}
static void *_p_FIX__PosReqTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PosReqType *) x));
}
static void *_p_FIX__AllocIntermedReqTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AllocIntermedReqType *) x));
}
static void *_p_FIX__StreamAsgnReqTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::StreamAsgnReqType *) x));
}
static void *_p_FIX__ApplReqTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ApplReqType *) x));
}
static void *_p_FIX__EncodedSubjectLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedSubjectLen *) x));
}
static void *_p_FIX__DeliveryTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DeliveryType *) x));
}
static void *_p_FIX__SettlDeliveryTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SettlDeliveryType *) x));
}
static void *_p_FIX__NewsCategoryTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NewsCategory *) x));
}
static void *_p_FIX__PartyRelationshipTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PartyRelationship *) x));
}
static void *_p_FIX__TrdTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TrdType *) x));
}
static void *_p_FIX__SecondaryTrdTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SecondaryTrdType *) x));
}
static void *_p_FIX__TotNoRelatedSymTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoRelatedSym *) x));
}
static void *_p_FIX__NoRelatedSymTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRelatedSym *) x));
}
static void *_p_FIX__ExpirationCycleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ExpirationCycle *) x));
}
static void *_p_FIX__ApplQueueMaxTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ApplQueueMax *) x));
}
static void *_p_FIX__NoRelatedPartyAltIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRelatedPartyAltIDs *) x));
}
static void *_p_FIX__NoPartyAltIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoPartyAltIDs *) x));
}
static void *_p_FIX__CollActionTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CollAction *) x));
}
static void *_p_FIX__PosMaintActionTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PosMaintAction *) x));
}
static void *_p_FIX__NewsRefTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NewsRefType *) x));
}
static void *_p_FIX__ApplQueueActionTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ApplQueueAction *) x));
}
static void *_p_FIX__LinesOfTextTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LinesOfText *) x));
}
static void *_p_FIX__MassActionScopeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MassActionScope *) x));
}
static void *_p_FIX__NoLinesOfTextTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoLinesOfText *) x));
}
static void *_p_FIX__DiscretionScopeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DiscretionScope *) x));
}
static void *_p_FIX__DerivativeInstrAttribTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeInstrAttribType *) x));
}
static void *_p_FIX__NestedInstrAttribTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NestedInstrAttribType *) x));
}
static void *_p_FIX__InstrAttribTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::InstrAttribType *) x));
}
static void *_p_FIX__NetGrossIndTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NetGrossInd *) x));
}
static void *_p_FIX__NoTickRulesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoTickRules *) x));
}
static void *_p_FIX__NoOfSecSizesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoOfSecSizes *) x));
}
static void *_p_FIX__StreamAsgnTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::StreamAsgnType *) x));
}
static void *_p_FIX__NoStrikesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoStrikes *) x));
}
static void *_p_FIX__TotNoStrikesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoStrikes *) x));
}
static void *_p_FIX__RefTagIDTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RefTagID *) x));
}
static void *_p_FIX__NoExecsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoExecs *) x));
}
static void *_p_FIX__SideMultiLegReportingTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SideMultiLegReportingType *) x));
}
static void *_p_FIX__RoutingTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RoutingType *) x));
}
static void *_p_FIX__BookingTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::BookingType *) x));
}
static void *_p_FIX__NumDaysInterestTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NumDaysInterest *) x));
}
static void *_p_FIX__PartyDetailsRequestResultTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PartyDetailsRequestResult *) x));
}
static void *_p_FIX__TradeRequestResultTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TradeRequestResult *) x));
}
static void *_p_FIX__SecurityRequestResultTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityRequestResult *) x));
}
static void *_p_FIX__PosMaintResultTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PosMaintResult *) x));
}
static void *_p_FIX__CollInquiryResultTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CollInquiryResult *) x));
}
static void *_p_FIX__PosReqResultTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PosReqResult *) x));
}
static void *_p_FIX__RawDataLengthTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RawDataLength *) x));
}
static void *_p_FIX__BodyLengthTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::BodyLength *) x));
}
static void *_p_FIX__SignatureLengthTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SignatureLength *) x));
}
static void *_p_FIX__EncodedSymbolLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedSymbolLen *) x));
}
static void *_p_FIX__ApplExtIDTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ApplExtID *) x));
}
static void *_p_FIX__DefaultApplExtIDTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DefaultApplExtID *) x));
}
static void *_p_FIX__RefApplExtIDTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RefApplExtID *) x));
}
static void *_p_FIX__NoRoutingIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRoutingIDs *) x));
}
static void *_p_FIX__NewSeqNoTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NewSeqNo *) x));
}
static void *_p_FIX__MaturityMonthYearIncrementUnitsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MaturityMonthYearIncrementUnits *) x));
}
static void *_p_FIX__HaltReasonIntTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::HaltReasonInt *) x));
}
static void *_p_FIX__NoUnderlyingStipsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoUnderlyingStips *) x));
}
static void *_p_FIX__ConfirmTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ConfirmType *) x));
}
static void *_p_FIX__TradSesEndTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::TradSesEndTime *) x));
}
static void *_p_FIX__OrigTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::OrigTime *) x));
}
static void *_p_FIX__DerivativeEventTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::DerivativeEventTime *) x));
}
static void *_p_FIX__EventTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::EventTime *) x));
}
static void *_p_FIX__OrigOrdModTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::OrigOrdModTime *) x));
}
static void *_p_FIX__TradSesOpenTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::TradSesOpenTime *) x));
}
static void *_p_FIX__ExecValuationPointTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::ExecValuationPoint *) x));
}
static void *_p_FIX__SideTimeInForceTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::SideTimeInForce *) x));
}
static void *_p_FIX__ComplexEventStartDateTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::ComplexEventStartDate *) x));
}
static void *_p_FIX__ExpireTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::ExpireTime *) x));
}
static void *_p_FIX__TransBkdTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::TransBkdTime *) x));
}
static void *_p_FIX__TradSesPreCloseTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::TradSesPreCloseTime *) x));
}
static void *_p_FIX__TradSesCloseTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::TradSesCloseTime *) x));
}
static void *_p_FIX__TradSesStartTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::TradSesStartTime *) x));
}
static void *_p_FIX__StrikeTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::StrikeTime *) x));
}
static void *_p_FIX__LastUpdateTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::LastUpdateTime *) x));
}
static void *_p_FIX__QuoteSetValidUntilTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::QuoteSetValidUntilTime *) x));
}
static void *_p_FIX__ValidUntilTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::ValidUntilTime *) x));
}
static void *_p_FIX__RelSymTransactTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::RelSymTransactTime *) x));
}
static void *_p_FIX__SideTrdRegTimestampTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::SideTrdRegTimestamp *) x));
}
static void *_p_FIX__ContraTradeTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::ContraTradeTime *) x));
}
static void *_p_FIX__TransactTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::TransactTime *) x));
}
static void *_p_FIX__TrdRegTimestampTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::TrdRegTimestamp *) x));
}
static void *_p_FIX__OrigSendingTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::OrigSendingTime *) x));
}
static void *_p_FIX__ComplexEventEndDateTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::ComplexEventEndDate *) x));
}
static void *_p_FIX__HopSendingTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::HopSendingTime *) x));
}
static void *_p_FIX__OnBehalfOfSendingTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::OnBehalfOfSendingTime *) x));
}
static void *_p_FIX__SendingTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::SendingTime *) x));
}
static void *_p_FIX__EffectiveTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::EffectiveTime *) x));
}
static void *_p_FIX__InViewOfCommonTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::InViewOfCommon *) x));
}
static void *_p_FIX__PrivateQuoteTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::PrivateQuote *) x));
}
static void *_p_FIX__ResetSeqNumFlagTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::ResetSeqNumFlag *) x));
}
static void *_p_FIX__DueToRelatedTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::DueToRelated *) x));
}
static void *_p_FIX__AggregatedBookTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::AggregatedBook *) x));
}
static void *_p_FIX__LegalConfirmTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::LegalConfirm *) x));
}
static void *_p_FIX__ForexReqTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::ForexReq *) x));
}
static void *_p_FIX__RefreshIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::RefreshIndicator *) x));
}
static void *_p_FIX__DefaultVerIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::DefaultVerIndicator *) x));
}
static void *_p_FIX__RiskFlexibleIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::RiskFlexibleIndicator *) x));
}
static void *_p_FIX__TrdRepIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::TrdRepIndicator *) x));
}
static void *_p_FIX__PublishTrdIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::PublishTrdIndicator *) x));
}
static void *_p_FIX__WorkingIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::WorkingIndicator *) x));
}
static void *_p_FIX__LateIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::LateIndicator *) x));
}
static void *_p_FIX__FlexibleIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::FlexibleIndicator *) x));
}
static void *_p_FIX__AutoAcceptIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::AutoAcceptIndicator *) x));
}
static void *_p_FIX__UnsolicitedIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::UnsolicitedIndicator *) x));
}
static void *_p_FIX__CopyMsgIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::CopyMsgIndicator *) x));
}
static void *_p_FIX__RelationshipRiskFlexibleIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::RelationshipRiskFlexibleIndicator *) x));
}
static void *_p_FIX__DerivFlexProductEligibilityIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::DerivFlexProductEligibilityIndicator *) x));
}
static void *_p_FIX__TestMessageIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::TestMessageIndicator *) x));
}
static void *_p_FIX__PriorSpreadIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::PriorSpreadIndicator *) x));
}
static void *_p_FIX__ManualOrderIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::ManualOrderIndicator *) x));
}
static void *_p_FIX__ReportToExchTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::ReportToExch *) x));
}
static void *_p_FIX__ContraryInstructionIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::ContraryInstructionIndicator *) x));
}
static void *_p_FIX__ReversalIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::ReversalIndicator *) x));
}
static void *_p_FIX__FlexProductEligibilityIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::FlexProductEligibilityIndicator *) x));
}
static void *_p_FIX__AggressorIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::AggressorIndicator *) x));
}
static void *_p_FIX__IOINaturalFlagTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::IOINaturalFlag *) x));
}
static void *_p_FIX__ExchangeForPhysicalTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::ExchangeForPhysical *) x));
}
static void *_p_FIX__LastRptRequestedTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::LastRptRequested *) x));
}
static void *_p_FIX__SolicitedFlagTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::SolicitedFlag *) x));
}
static void *_p_FIX__TradedFlatSwitchTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::TradedFlatSwitch *) x));
}
static void *_p_FIX__CustDirectedOrderTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::CustDirectedOrder *) x));
}
static void *_p_FIX__LocateReqdTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::LocateReqd *) x));
}
static void *_p_FIX__NotifyBrokerOfCreditTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::NotifyBrokerOfCredit *) x));
}
static void *_p_FIX__MDImplicitDeleteTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::MDImplicitDelete *) x));
}
static void *_p_FIX__PossResendTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::PossResend *) x));
}
static void *_p_FIX__PossDupFlagTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::PossDupFlag *) x));
}
static void *_p_FIX__PreTradeAnonymityTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::PreTradeAnonymity *) x));
}
static void *_p_FIX__ReportedPxDiffTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::ReportedPxDiff *) x));
}
static void *_p_FIX__ApplResendFlagTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::ApplResendFlag *) x));
}
static void *_p_FIX__PreviouslyReportedTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::PreviouslyReported *) x));
}
static void *_p_FIX__OddLotTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::OddLot *) x));
}
static void *_p_FIX__LastFragmentTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::LastFragment *) x));
}
static void *_p_FIX__GapFillFlagTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::GapFillFlag *) x));
}
static void *_p_FIX__MDEntryTimeTo_p_FIX__UtcTimeOnlyField(void *x) {
    return (void *)((FIX::UtcTimeOnlyField *)  ((FIX::MDEntryTime *) x));
}
static void *_p_FIX__ComplexEventStartTimeTo_p_FIX__UtcTimeOnlyField(void *x) {
    return (void *)((FIX::UtcTimeOnlyField *)  ((FIX::ComplexEventStartTime *) x));
}
static void *_p_FIX__TotalVolumeTradedTimeTo_p_FIX__UtcTimeOnlyField(void *x) {
    return (void *)((FIX::UtcTimeOnlyField *)  ((FIX::TotalVolumeTradedTime *) x));
}
static void *_p_FIX__ComplexEventEndTimeTo_p_FIX__UtcTimeOnlyField(void *x) {
    return (void *)((FIX::UtcTimeOnlyField *)  ((FIX::ComplexEventEndTime *) x));
}
static void *_p_FIX__MDEntryDateTo_p_FIX__UtcDateField(void *x) {
    return (void *)((FIX::UtcDateField *)  ((FIX::MDEntryDate *) x));
}
static void *_p_FIX__TotalVolumeTradedDateTo_p_FIX__UtcDateField(void *x) {
    return (void *)((FIX::UtcDateField *)  ((FIX::TotalVolumeTradedDate *) x));
}
static void *_p_FIX__DerivativeUnitOfMeasureQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeUnitOfMeasureQty *) x));
}
static void *_p_FIX__LegPriceUnitOfMeasureQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegPriceUnitOfMeasureQty *) x));
}
static void *_p_FIX__UnderlyingUnitOfMeasureQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingUnitOfMeasureQty *) x));
}
static void *_p_FIX__UnitOfMeasureQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnitOfMeasureQty *) x));
}
static void *_p_FIX__UnderlyingLastPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingLastPx *) x));
}
static void *_p_FIX__DerivativePriceUnitOfMeasureQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativePriceUnitOfMeasureQty *) x));
}
static void *_p_FIX__LegLastPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegLastPx *) x));
}
static void *_p_FIX__UnderlyingPriceUnitOfMeasureQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingPriceUnitOfMeasureQty *) x));
}
static void *_p_FIX__PriceUnitOfMeasureQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::PriceUnitOfMeasureQty *) x));
}
static void *_p_FIX__LegUnitOfMeasureQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegUnitOfMeasureQty *) x));
}
static void *_p_FIX__ReportedPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::ReportedPx *) x));
}
static void *_p_FIX__UnderlyingCapValueTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingCapValue *) x));
}
static void *_p_FIX__DisplayLowQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DisplayLowQty *) x));
}
static void *_p_FIX__LegRatioQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegRatioQty *) x));
}
static void *_p_FIX__RatioQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::RatioQty *) x));
}
static void *_p_FIX__RoundingModulusTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::RoundingModulus *) x));
}
static void *_p_FIX__MDEntrySizeTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MDEntrySize *) x));
}
static void *_p_FIX__ComplexEventPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::ComplexEventPrice *) x));
}
static void *_p_FIX__LeavesQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LeavesQty *) x));
}
static void *_p_FIX__QuantityTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::Quantity *) x));
}
static void *_p_FIX__UnderlyingAdjustedQuantityTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingAdjustedQuantity *) x));
}
static void *_p_FIX__DisplayMinIncrTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DisplayMinIncr *) x));
}
static void *_p_FIX__TotalTakedownTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::TotalTakedown *) x));
}
static void *_p_FIX__UnderlyingFactorTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingFactor *) x));
}
static void *_p_FIX__LegFactorTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegFactor *) x));
}
static void *_p_FIX__AccruedInterestAmtTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::AccruedInterestAmt *) x));
}
static void *_p_FIX__TotalAccruedInterestAmtTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::TotalAccruedInterestAmt *) x));
}
static void *_p_FIX__AllocAccruedInterestAmtTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllocAccruedInterestAmt *) x));
}
static void *_p_FIX__EndAccruedInterestAmtTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::EndAccruedInterestAmt *) x));
}
static void *_p_FIX__FloorPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::FloorPrice *) x));
}
static void *_p_FIX__TriggerPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::TriggerPrice *) x));
}
static void *_p_FIX__DerivativeFloorPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeFloorPrice *) x));
}
static void *_p_FIX__UnderlyingOriginalNotionalPercentageOutstandingTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingOriginalNotionalPercentageOutstanding *) x));
}
static void *_p_FIX__StopPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::StopPx *) x));
}
static void *_p_FIX__ThresholdAmountTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::ThresholdAmount *) x));
}
static void *_p_FIX__UnderlyingCashAmountTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingCashAmount *) x));
}
static void *_p_FIX__RiskLimitAmountTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::RiskLimitAmount *) x));
}
static void *_p_FIX__DerivativeMinPriceIncrementAmountTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeMinPriceIncrementAmount *) x));
}
static void *_p_FIX__RelationshipRiskLimitAmountTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::RelationshipRiskLimitAmount *) x));
}
static void *_p_FIX__ComplexOptPayoutAmountTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::ComplexOptPayoutAmount *) x));
}
static void *_p_FIX__UnderlyingCollectAmountTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingCollectAmount *) x));
}
static void *_p_FIX__OptPayoutAmountTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OptPayoutAmount *) x));
}
static void *_p_FIX__MinPriceIncrementAmountTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MinPriceIncrementAmount *) x));
}
static void *_p_FIX__UnderlyingDirtyPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingDirtyPrice *) x));
}
static void *_p_FIX__AvgParPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::AvgParPx *) x));
}
static void *_p_FIX__ShortQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::ShortQty *) x));
}
static void *_p_FIX__MinQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MinQty *) x));
}
static void *_p_FIX__TriggerNewPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::TriggerNewPrice *) x));
}
static void *_p_FIX__AllocAvgPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllocAvgPx *) x));
}
static void *_p_FIX__PeggedRefPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::PeggedRefPrice *) x));
}
static void *_p_FIX__ContraTradeQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::ContraTradeQty *) x));
}
static void *_p_FIX__OrderBookingQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OrderBookingQty *) x));
}
static void *_p_FIX__CommissionTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::Commission *) x));
}
static void *_p_FIX__DayAvgPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DayAvgPx *) x));
}
static void *_p_FIX__SharedCommissionTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::SharedCommission *) x));
}
static void *_p_FIX__UnderlyingQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingQty *) x));
}
static void *_p_FIX__SpreadToBenchmarkTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::SpreadToBenchmark *) x));
}
static void *_p_FIX__RepurchaseRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::RepurchaseRate *) x));
}
static void *_p_FIX__UnderlyingRepurchaseRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingRepurchaseRate *) x));
}
static void *_p_FIX__LegRepurchaseRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegRepurchaseRate *) x));
}
static void *_p_FIX__AttachmentPointTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::AttachmentPoint *) x));
}
static void *_p_FIX__UnderlyingAttachmentPointTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingAttachmentPoint *) x));
}
static void *_p_FIX__DetachmentPointTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DetachmentPoint *) x));
}
static void *_p_FIX__UnderlyingDetachmentPointTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingDetachmentPoint *) x));
}
static void *_p_FIX__LegOptionRatioTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegOptionRatio *) x));
}
static void *_p_FIX__MarginRatioTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MarginRatio *) x));
}
static void *_p_FIX__UnderlyingEndValueTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingEndValue *) x));
}
static void *_p_FIX__RiskInstrumentMultiplierTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::RiskInstrumentMultiplier *) x));
}
static void *_p_FIX__StrikeMultiplierTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::StrikeMultiplier *) x));
}
static void *_p_FIX__ContractMultiplierTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::ContractMultiplier *) x));
}
static void *_p_FIX__LegContractMultiplierTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegContractMultiplier *) x));
}
static void *_p_FIX__UnderlyingContractMultiplierTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingContractMultiplier *) x));
}
static void *_p_FIX__FeeMultiplierTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::FeeMultiplier *) x));
}
static void *_p_FIX__RelationshipRiskInstrumentMultiplierTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::RelationshipRiskInstrumentMultiplier *) x));
}
static void *_p_FIX__DerivativeContractMultiplierTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeContractMultiplier *) x));
}
static void *_p_FIX__DerivativeStrikeMultiplierTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeStrikeMultiplier *) x));
}
static void *_p_FIX__AllowableOneSidednessValueTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllowableOneSidednessValue *) x));
}
static void *_p_FIX__TimeToExpirationTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::TimeToExpiration *) x));
}
static void *_p_FIX__OfferForwardPointsTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OfferForwardPoints *) x));
}
static void *_p_FIX__MDEntryForwardPointsTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MDEntryForwardPoints *) x));
}
static void *_p_FIX__BidForwardPointsTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::BidForwardPoints *) x));
}
static void *_p_FIX__OfferSwapPointsTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OfferSwapPoints *) x));
}
static void *_p_FIX__BidSwapPointsTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::BidSwapPoints *) x));
}
static void *_p_FIX__SideGrossTradeAmtTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::SideGrossTradeAmt *) x));
}
static void *_p_FIX__GrossTradeAmtTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::GrossTradeAmt *) x));
}
static void *_p_FIX__LegOfferForwardPointsTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegOfferForwardPoints *) x));
}
static void *_p_FIX__LegGrossTradeAmtTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegGrossTradeAmt *) x));
}
static void *_p_FIX__LegLastForwardPointsTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegLastForwardPoints *) x));
}
static void *_p_FIX__SwapPointsTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::SwapPoints *) x));
}
static void *_p_FIX__LastForwardPointsTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LastForwardPoints *) x));
}
static void *_p_FIX__LegBidForwardPointsTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegBidForwardPoints *) x));
}
static void *_p_FIX__LastSwapPointsTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LastSwapPoints *) x));
}
static void *_p_FIX__UnderlyingFXRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingFXRate *) x));
}
static void *_p_FIX__UnderlyingDeliveryAmountTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingDeliveryAmount *) x));
}
static void *_p_FIX__CapPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::CapPrice *) x));
}
static void *_p_FIX__DerivativeOptPayAmountTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeOptPayAmount *) x));
}
static void *_p_FIX__DerivativeCapPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeCapPrice *) x));
}
static void *_p_FIX__NetChgPrevDayTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::NetChgPrevDay *) x));
}
static void *_p_FIX__UnderlyingPayAmountTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingPayAmount *) x));
}
static void *_p_FIX__OptPayAmountTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OptPayAmount *) x));
}
static void *_p_FIX__OfferPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OfferPx *) x));
}
static void *_p_FIX__MktOfferPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MktOfferPx *) x));
}
static void *_p_FIX__OfferYieldTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OfferYield *) x));
}
static void *_p_FIX__LegOfferPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegOfferPx *) x));
}
static void *_p_FIX__MidPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MidPx *) x));
}
static void *_p_FIX__PegDifferenceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::PegDifference *) x));
}
static void *_p_FIX__HighPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::HighPx *) x));
}
static void *_p_FIX__MiscFeeAmtTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MiscFeeAmt *) x));
}
static void *_p_FIX__OrderAvgPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OrderAvgPx *) x));
}
static void *_p_FIX__LastParPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LastParPx *) x));
}
static void *_p_FIX__PriceImprovementTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::PriceImprovement *) x));
}
static void *_p_FIX__OutsideIndexPctTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OutsideIndexPct *) x));
}
static void *_p_FIX__AllowableOneSidednessPctTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllowableOneSidednessPct *) x));
}
static void *_p_FIX__SellVolumeTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::SellVolume *) x));
}
static void *_p_FIX__PeggedPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::PeggedPrice *) x));
}
static void *_p_FIX__PrevClosePxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::PrevClosePx *) x));
}
static void *_p_FIX__RndPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::RndPx *) x));
}
static void *_p_FIX__EndStrikePxRangeTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::EndStrikePxRange *) x));
}
static void *_p_FIX__StartStrikePxRangeTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::StartStrikePxRange *) x));
}
static void *_p_FIX__LastQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LastQty *) x));
}
static void *_p_FIX__LegCalculatedCcyLastQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegCalculatedCcyLastQty *) x));
}
static void *_p_FIX__LegLastQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegLastQty *) x));
}
static void *_p_FIX__LastForwardPoints2To_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LastForwardPoints2 *) x));
}
static void *_p_FIX__OfferForwardPoints2To_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OfferForwardPoints2 *) x));
}
static void *_p_FIX__UnderlyingPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingPx *) x));
}
static void *_p_FIX__BidForwardPoints2To_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::BidForwardPoints2 *) x));
}
static void *_p_FIX__CalculatedCcyLastQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::CalculatedCcyLastQty *) x));
}
static void *_p_FIX__UnderlyingLastQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingLastQty *) x));
}
static void *_p_FIX__SecondaryDisplayQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::SecondaryDisplayQty *) x));
}
static void *_p_FIX__BenchmarkPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::BenchmarkPrice *) x));
}
static void *_p_FIX__LegBenchmarkPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegBenchmarkPrice *) x));
}
static void *_p_FIX__DisplayQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DisplayQty *) x));
}
static void *_p_FIX__OrderQty2To_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OrderQty2 *) x));
}
static void *_p_FIX__StartTickPriceRangeTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::StartTickPriceRange *) x));
}
static void *_p_FIX__SpreadTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::Spread *) x));
}
static void *_p_FIX__EndTickPriceRangeTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::EndTickPriceRange *) x));
}
static void *_p_FIX__DiscretionOffsetTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DiscretionOffset *) x));
}
static void *_p_FIX__ParticipationRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::ParticipationRate *) x));
}
static void *_p_FIX__LiquidityPctLowTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LiquidityPctLow *) x));
}
static void *_p_FIX__AllocQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllocQty *) x));
}
static void *_p_FIX__LegAllocQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegAllocQty *) x));
}
static void *_p_FIX__FirstPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::FirstPx *) x));
}
static void *_p_FIX__MDEntrySpotRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MDEntrySpotRate *) x));
}
static void *_p_FIX__TargetStrategyPerformanceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::TargetStrategyPerformance *) x));
}
static void *_p_FIX__CashOutstandingTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::CashOutstanding *) x));
}
static void *_p_FIX__UnderlyingNotionalPercentageOutstandingTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingNotionalPercentageOutstanding *) x));
}
static void *_p_FIX__DiscretionPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DiscretionPrice *) x));
}
static void *_p_FIX__BidSpotRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::BidSpotRate *) x));
}
static void *_p_FIX__YieldRedemptionPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::YieldRedemptionPrice *) x));
}
static void *_p_FIX__OfferSpotRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OfferSpotRate *) x));
}
static void *_p_FIX__NotionalPercentageOutstandingTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::NotionalPercentageOutstanding *) x));
}
static void *_p_FIX__LastSpotRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LastSpotRate *) x));
}
static void *_p_FIX__OriginalNotionalPercentageOutstandingTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OriginalNotionalPercentageOutstanding *) x));
}
static void *_p_FIX__SettlCurrAmtTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::SettlCurrAmt *) x));
}
static void *_p_FIX__AllocSettlCurrAmtTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllocSettlCurrAmt *) x));
}
static void *_p_FIX__TradeVolumeTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::TradeVolume *) x));
}
static void *_p_FIX__BuyVolumeTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::BuyVolume *) x));
}
static void *_p_FIX__UnderlyingEndPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingEndPrice *) x));
}
static void *_p_FIX__BidPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::BidPx *) x));
}
static void *_p_FIX__StrikeValueTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::StrikeValue *) x));
}
static void *_p_FIX__PosAmtTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::PosAmt *) x));
}
static void *_p_FIX__DerivativeStrikeValueTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeStrikeValue *) x));
}
static void *_p_FIX__DisplayHighQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DisplayHighQty *) x));
}
static void *_p_FIX__SettlCurrFxRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::SettlCurrFxRate *) x));
}
static void *_p_FIX__SettlCurrOfferFxRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::SettlCurrOfferFxRate *) x));
}
static void *_p_FIX__SettlCurrBidFxRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::SettlCurrBidFxRate *) x));
}
static void *_p_FIX__MidYieldTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MidYield *) x));
}
static void *_p_FIX__BidYieldTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::BidYield *) x));
}
static void *_p_FIX__MinTradeVolTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MinTradeVol *) x));
}
static void *_p_FIX__MaxTradeVolTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MaxTradeVol *) x));
}
static void *_p_FIX__LegBidPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegBidPx *) x));
}
static void *_p_FIX__FillQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::FillQty *) x));
}
static void *_p_FIX__PriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::Price *) x));
}
static void *_p_FIX__EndCashTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::EndCash *) x));
}
static void *_p_FIX__ConcessionTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::Concession *) x));
}
static void *_p_FIX__RiskCouponRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::RiskCouponRate *) x));
}
static void *_p_FIX__RelationshipRiskCouponRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::RelationshipRiskCouponRate *) x));
}
static void *_p_FIX__CcyAmtTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::CcyAmt *) x));
}
static void *_p_FIX__UnderlyingCouponRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingCouponRate *) x));
}
static void *_p_FIX__LastSharesTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LastShares *) x));
}
static void *_p_FIX__CouponRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::CouponRate *) x));
}
static void *_p_FIX__LegCouponRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegCouponRate *) x));
}
static void *_p_FIX__SharesTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::Shares *) x));
}
static void *_p_FIX__LegPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegPrice *) x));
}
static void *_p_FIX__AssignmentUnitTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::AssignmentUnit *) x));
}
static void *_p_FIX__OutMainCntryUIndexTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OutMainCntryUIndex *) x));
}
static void *_p_FIX__LegQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegQty *) x));
}
static void *_p_FIX__MaxShowTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MaxShow *) x));
}
static void *_p_FIX__RoundLotTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::RoundLot *) x));
}
static void *_p_FIX__RiskFreeRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::RiskFreeRate *) x));
}
static void *_p_FIX__OrderCapacityQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OrderCapacityQty *) x));
}
static void *_p_FIX__PctAtRiskTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::PctAtRisk *) x));
}
static void *_p_FIX__RefreshQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::RefreshQty *) x));
}
static void *_p_FIX__ExpQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::ExpQty *) x));
}
static void *_p_FIX__MarginExcessTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MarginExcess *) x));
}
static void *_p_FIX__PegOffsetValueTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::PegOffsetValue *) x));
}
static void *_p_FIX__ContAmtValueTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::ContAmtValue *) x));
}
static void *_p_FIX__DiscretionOffsetValueTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DiscretionOffsetValue *) x));
}
static void *_p_FIX__TotalNetValueTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::TotalNetValue *) x));
}
static void *_p_FIX__MinPriceIncrementTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MinPriceIncrement *) x));
}
static void *_p_FIX__DerivativeMinPriceIncrementTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeMinPriceIncrement *) x));
}
static void *_p_FIX__TickIncrementTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::TickIncrement *) x));
}
static void *_p_FIX__MatchIncrementTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MatchIncrement *) x));
}
static void *_p_FIX__StrikeIncrementTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::StrikeIncrement *) x));
}
static void *_p_FIX__DividendYieldTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DividendYield *) x));
}
static void *_p_FIX__LegDividendYieldTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegDividendYield *) x));
}
static void *_p_FIX__MDEntryPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MDEntryPx *) x));
}
static void *_p_FIX__MaxFloorTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MaxFloor *) x));
}
static void *_p_FIX__AllocInterestAtMaturityTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllocInterestAtMaturity *) x));
}
static void *_p_FIX__InterestAtMaturityTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::InterestAtMaturity *) x));
}
static void *_p_FIX__CxlQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::CxlQty *) x));
}
static void *_p_FIX__MaxPriceVariationTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MaxPriceVariation *) x));
}
static void *_p_FIX__AllocSharesTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllocShares *) x));
}
static void *_p_FIX__EventPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::EventPx *) x));
}
static void *_p_FIX__DerivativeEventPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeEventPx *) x));
}
static void *_p_FIX__YieldTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::Yield *) x));
}
static void *_p_FIX__PriceDeltaTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::PriceDelta *) x));
}
static void *_p_FIX__LegVolatilityTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegVolatility *) x));
}
static void *_p_FIX__VolatilityTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::Volatility *) x));
}
static void *_p_FIX__MinBidSizeTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MinBidSize *) x));
}
static void *_p_FIX__DefBidSizeTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DefBidSize *) x));
}
static void *_p_FIX__BidSizeTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::BidSize *) x));
}
static void *_p_FIX__FillPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::FillPx *) x));
}
static void *_p_FIX__LegStrikePriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegStrikePrice *) x));
}
static void *_p_FIX__DerivativeStrikePriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeStrikePrice *) x));
}
static void *_p_FIX__SecondaryTradingReferencePriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::SecondaryTradingReferencePrice *) x));
}
static void *_p_FIX__TradingReferencePriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::TradingReferencePrice *) x));
}
static void *_p_FIX__StrikePriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::StrikePrice *) x));
}
static void *_p_FIX__UnderlyingStrikePriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingStrikePrice *) x));
}
static void *_p_FIX__UnderlyingLegStrikePriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingLegStrikePrice *) x));
}
static void *_p_FIX__Price2To_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::Price2 *) x));
}
static void *_p_FIX__AvgPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::AvgPx *) x));
}
static void *_p_FIX__CurrencyRatioTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::CurrencyRatio *) x));
}
static void *_p_FIX__LegCurrencyRatioTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegCurrencyRatio *) x));
}
static void *_p_FIX__SettlPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::SettlPrice *) x));
}
static void *_p_FIX__UnderlyingSettlPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingSettlPrice *) x));
}
static void *_p_FIX__CumQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::CumQty *) x));
}
static void *_p_FIX__PriorSettlPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::PriorSettlPrice *) x));
}
static void *_p_FIX__OpenInterestTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OpenInterest *) x));
}
static void *_p_FIX__DistribPercentageTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DistribPercentage *) x));
}
static void *_p_FIX__LegOrderQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegOrderQty *) x));
}
static void *_p_FIX__CashOrderQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::CashOrderQty *) x));
}
static void *_p_FIX__DayOrderQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DayOrderQty *) x));
}
static void *_p_FIX__OrderQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OrderQty *) x));
}
static void *_p_FIX__AllocNetMoneyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllocNetMoney *) x));
}
static void *_p_FIX__NetMoneyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::NetMoney *) x));
}
static void *_p_FIX__MaturityNetMoneyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MaturityNetMoney *) x));
}
static void *_p_FIX__LongQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LongQty *) x));
}
static void *_p_FIX__ExecPriceAdjustmentTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::ExecPriceAdjustment *) x));
}
static void *_p_FIX__UnderlyingStartValueTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingStartValue *) x));
}
static void *_p_FIX__UnderlyingCurrentValueTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingCurrentValue *) x));
}
static void *_p_FIX__LastPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LastPx *) x));
}
static void *_p_FIX__MinOfferSizeTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MinOfferSize *) x));
}
static void *_p_FIX__OfferSizeTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OfferSize *) x));
}
static void *_p_FIX__DefOfferSizeTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DefOfferSize *) x));
}
static void *_p_FIX__FairValueTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::FairValue *) x));
}
static void *_p_FIX__LowPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LowPx *) x));
}
static void *_p_FIX__SideValue1To_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::SideValue1 *) x));
}
static void *_p_FIX__SideValue2To_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::SideValue2 *) x));
}
static void *_p_FIX__MktBidPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MktBidPx *) x));
}
static void *_p_FIX__LiquidityValueTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LiquidityValue *) x));
}
static void *_p_FIX__StartCashTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::StartCash *) x));
}
static void *_p_FIX__WtAverageLiquidityTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::WtAverageLiquidity *) x));
}
static void *_p_FIX__TotalVolumeTradedTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::TotalVolumeTraded *) x));
}
static void *_p_FIX__BasisFeaturePriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::BasisFeaturePrice *) x));
}
static void *_p_FIX__EFPTrackingErrorTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::EFPTrackingError *) x));
}
static void *_p_FIX__TriggerNewQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::TriggerNewQty *) x));
}
static void *_p_FIX__ComplexEventPriceBoundaryPrecisionTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::ComplexEventPriceBoundaryPrecision *) x));
}
static void *_p_FIX__StrikePriceBoundaryPrecisionTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::StrikePriceBoundaryPrecision *) x));
}
static void *_p_FIX__SecondaryHighLimitPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::SecondaryHighLimitPrice *) x));
}
static void *_p_FIX__HighLimitPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::HighLimitPrice *) x));
}
static void *_p_FIX__SecondaryLowLimitPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::SecondaryLowLimitPrice *) x));
}
static void *_p_FIX__LowLimitPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LowLimitPrice *) x));
}
static void *_p_FIX__MinLotSizeTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MinLotSize *) x));
}
static void *_p_FIX__AllocPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllocPrice *) x));
}
static void *_p_FIX__ValueOfFuturesTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::ValueOfFutures *) x));
}
static void *_p_FIX__FactorTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::Factor *) x));
}
static void *_p_FIX__DayCumQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DayCumQty *) x));
}
static void *_p_FIX__LiquidityPctHighTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LiquidityPctHigh *) x));
}
static void *_p_FIX__CrossPercentTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::CrossPercent *) x));
}
static void *_p_FIX__RiskWarningLevelPercentTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::RiskWarningLevelPercent *) x));
}
static void *_p_FIX__OrderPercentTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OrderPercent *) x));
}
static void *_p_FIX__UnderlyingAllocationPercentTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingAllocationPercent *) x));
}
static void *_p_FIX__AccruedInterestRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::AccruedInterestRate *) x));
}
static void *_p_FIX__RelationshipRiskWarningLevelPercentTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::RelationshipRiskWarningLevelPercent *) x));
}
static void *_p_FIX__MDSecSizeTo_p_FIX__DoubleField(void *x) {
    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_DateTime = {"_p_DateTime", "DateTime *", 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 *|PercentageField *", 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__AsgnReqID = {"_p_FIX__AsgnReqID", "FIX::AsgnReqID *", 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__ContextPartyID = {"_p_FIX__ContextPartyID", "FIX::ContextPartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContextPartyIDSource = {"_p_FIX__ContextPartyIDSource", "FIX::ContextPartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContextPartyRole = {"_p_FIX__ContextPartyRole", "FIX::ContextPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContextPartySubID = {"_p_FIX__ContextPartySubID", "FIX::ContextPartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContextPartySubIDType = {"_p_FIX__ContextPartySubIDType", "FIX::ContextPartySubIDType *", 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__DerivativeSecurityListRequestType = {"_p_FIX__DerivativeSecurityListRequestType", "FIX::DerivativeSecurityListRequestType *", 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::PercentageField *", 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__EncodedSymbol = {"_p_FIX__EncodedSymbol", "FIX::EncodedSymbol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedSymbolLen = {"_p_FIX__EncodedSymbolLen", "FIX::EncodedSymbolLen *", 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 *|FIX::Trailer *", 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__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::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__NoContextPartyIDs = {"_p_FIX__NoContextPartyIDs", "FIX::NoContextPartyIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoContextPartySubIDs = {"_p_FIX__NoContextPartySubIDs", "FIX::NoContextPartySubIDs *", 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__NoPartyAltIDs = {"_p_FIX__NoPartyAltIDs", "FIX::NoPartyAltIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoPartyAltSubIDs = {"_p_FIX__NoPartyAltSubIDs", "FIX::NoPartyAltSubIDs *", 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__NoPartyList = {"_p_FIX__NoPartyList", "FIX::NoPartyList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoPartyListResponseTypes = {"_p_FIX__NoPartyListResponseTypes", "FIX::NoPartyListResponseTypes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoPartyRelationships = {"_p_FIX__NoPartyRelationships", "FIX::NoPartyRelationships *", 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__NoRelatedContextPartyIDs = {"_p_FIX__NoRelatedContextPartyIDs", "FIX::NoRelatedContextPartyIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRelatedContextPartySubIDs = {"_p_FIX__NoRelatedContextPartySubIDs", "FIX::NoRelatedContextPartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRelatedPartyAltIDs = {"_p_FIX__NoRelatedPartyAltIDs", "FIX::NoRelatedPartyAltIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRelatedPartyAltSubIDs = {"_p_FIX__NoRelatedPartyAltSubIDs", "FIX::NoRelatedPartyAltSubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRelatedPartyIDs = {"_p_FIX__NoRelatedPartyIDs", "FIX::NoRelatedPartyIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRelatedPartySubIDs = {"_p_FIX__NoRelatedPartySubIDs", "FIX::NoRelatedPartySubIDs *", 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__NoRelationshipRiskInstruments = {"_p_FIX__NoRelationshipRiskInstruments", "FIX::NoRelationshipRiskInstruments *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRelationshipRiskLimits = {"_p_FIX__NoRelationshipRiskLimits", "FIX::NoRelationshipRiskLimits *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRelationshipRiskSecurityAltID = {"_p_FIX__NoRelationshipRiskSecurityAltID", "FIX::NoRelationshipRiskSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRelationshipRiskWarningLevels = {"_p_FIX__NoRelationshipRiskWarningLevels", "FIX::NoRelationshipRiskWarningLevels *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRequestedPartyRoles = {"_p_FIX__NoRequestedPartyRoles", "FIX::NoRequestedPartyRoles *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRiskInstruments = {"_p_FIX__NoRiskInstruments", "FIX::NoRiskInstruments *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRiskLimits = {"_p_FIX__NoRiskLimits", "FIX::NoRiskLimits *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRiskSecurityAltID = {"_p_FIX__NoRiskSecurityAltID", "FIX::NoRiskSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRiskWarningLevels = {"_p_FIX__NoRiskWarningLevels", "FIX::NoRiskWarningLevels *", 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__PartyAltID = {"_p_FIX__PartyAltID", "FIX::PartyAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PartyAltIDSource = {"_p_FIX__PartyAltIDSource", "FIX::PartyAltIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PartyAltSubID = {"_p_FIX__PartyAltSubID", "FIX::PartyAltSubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PartyAltSubIDType = {"_p_FIX__PartyAltSubIDType", "FIX::PartyAltSubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PartyDetailsListReportID = {"_p_FIX__PartyDetailsListReportID", "FIX::PartyDetailsListReportID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PartyDetailsListRequestID = {"_p_FIX__PartyDetailsListRequestID", "FIX::PartyDetailsListRequestID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PartyDetailsRequestResult = {"_p_FIX__PartyDetailsRequestResult", "FIX::PartyDetailsRequestResult *", 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__PartyListResponseType = {"_p_FIX__PartyListResponseType", "FIX::PartyListResponseType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PartyRelationship = {"_p_FIX__PartyRelationship", "FIX::PartyRelationship *", 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__RelatedContextPartyID = {"_p_FIX__RelatedContextPartyID", "FIX::RelatedContextPartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelatedContextPartyIDSource = {"_p_FIX__RelatedContextPartyIDSource", "FIX::RelatedContextPartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelatedContextPartyRole = {"_p_FIX__RelatedContextPartyRole", "FIX::RelatedContextPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelatedContextPartySubID = {"_p_FIX__RelatedContextPartySubID", "FIX::RelatedContextPartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelatedContextPartySubIDType = {"_p_FIX__RelatedContextPartySubIDType", "FIX::RelatedContextPartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelatedPartyAltID = {"_p_FIX__RelatedPartyAltID", "FIX::RelatedPartyAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelatedPartyAltIDSource = {"_p_FIX__RelatedPartyAltIDSource", "FIX::RelatedPartyAltIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelatedPartyAltSubID = {"_p_FIX__RelatedPartyAltSubID", "FIX::RelatedPartyAltSubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelatedPartyAltSubIDType = {"_p_FIX__RelatedPartyAltSubIDType", "FIX::RelatedPartyAltSubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelatedPartyID = {"_p_FIX__RelatedPartyID", "FIX::RelatedPartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelatedPartyIDSource = {"_p_FIX__RelatedPartyIDSource", "FIX::RelatedPartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelatedPartyRole = {"_p_FIX__RelatedPartyRole", "FIX::RelatedPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelatedPartySubID = {"_p_FIX__RelatedPartySubID", "FIX::RelatedPartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelatedPartySubIDType = {"_p_FIX__RelatedPartySubIDType", "FIX::RelatedPartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskCFICode = {"_p_FIX__RelationshipRiskCFICode", "FIX::RelationshipRiskCFICode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskCouponRate = {"_p_FIX__RelationshipRiskCouponRate", "FIX::RelationshipRiskCouponRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskEncodedSecurityDesc = {"_p_FIX__RelationshipRiskEncodedSecurityDesc", "FIX::RelationshipRiskEncodedSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskEncodedSecurityDescLen = {"_p_FIX__RelationshipRiskEncodedSecurityDescLen", "FIX::RelationshipRiskEncodedSecurityDescLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskFlexibleIndicator = {"_p_FIX__RelationshipRiskFlexibleIndicator", "FIX::RelationshipRiskFlexibleIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskInstrumentMultiplier = {"_p_FIX__RelationshipRiskInstrumentMultiplier", "FIX::RelationshipRiskInstrumentMultiplier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskInstrumentOperator = {"_p_FIX__RelationshipRiskInstrumentOperator", "FIX::RelationshipRiskInstrumentOperator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskInstrumentSettlType = {"_p_FIX__RelationshipRiskInstrumentSettlType", "FIX::RelationshipRiskInstrumentSettlType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskLimitAmount = {"_p_FIX__RelationshipRiskLimitAmount", "FIX::RelationshipRiskLimitAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskLimitCurrency = {"_p_FIX__RelationshipRiskLimitCurrency", "FIX::RelationshipRiskLimitCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskLimitPlatform = {"_p_FIX__RelationshipRiskLimitPlatform", "FIX::RelationshipRiskLimitPlatform *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskLimitType = {"_p_FIX__RelationshipRiskLimitType", "FIX::RelationshipRiskLimitType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskMaturityMonthYear = {"_p_FIX__RelationshipRiskMaturityMonthYear", "FIX::RelationshipRiskMaturityMonthYear *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskMaturityTime = {"_p_FIX__RelationshipRiskMaturityTime", "FIX::RelationshipRiskMaturityTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskProduct = {"_p_FIX__RelationshipRiskProduct", "FIX::RelationshipRiskProduct *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskProductComplex = {"_p_FIX__RelationshipRiskProductComplex", "FIX::RelationshipRiskProductComplex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskPutOrCall = {"_p_FIX__RelationshipRiskPutOrCall", "FIX::RelationshipRiskPutOrCall *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskRestructuringType = {"_p_FIX__RelationshipRiskRestructuringType", "FIX::RelationshipRiskRestructuringType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskSecurityAltID = {"_p_FIX__RelationshipRiskSecurityAltID", "FIX::RelationshipRiskSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskSecurityAltIDSource = {"_p_FIX__RelationshipRiskSecurityAltIDSource", "FIX::RelationshipRiskSecurityAltIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskSecurityDesc = {"_p_FIX__RelationshipRiskSecurityDesc", "FIX::RelationshipRiskSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskSecurityExchange = {"_p_FIX__RelationshipRiskSecurityExchange", "FIX::RelationshipRiskSecurityExchange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskSecurityGroup = {"_p_FIX__RelationshipRiskSecurityGroup", "FIX::RelationshipRiskSecurityGroup *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskSecurityID = {"_p_FIX__RelationshipRiskSecurityID", "FIX::RelationshipRiskSecurityID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskSecurityIDSource = {"_p_FIX__RelationshipRiskSecurityIDSource", "FIX::RelationshipRiskSecurityIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskSecuritySubType = {"_p_FIX__RelationshipRiskSecuritySubType", "FIX::RelationshipRiskSecuritySubType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskSecurityType = {"_p_FIX__RelationshipRiskSecurityType", "FIX::RelationshipRiskSecurityType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskSeniority = {"_p_FIX__RelationshipRiskSeniority", "FIX::RelationshipRiskSeniority *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskSymbol = {"_p_FIX__RelationshipRiskSymbol", "FIX::RelationshipRiskSymbol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskSymbolSfx = {"_p_FIX__RelationshipRiskSymbolSfx", "FIX::RelationshipRiskSymbolSfx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskWarningLevelName = {"_p_FIX__RelationshipRiskWarningLevelName", "FIX::RelationshipRiskWarningLevelName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskWarningLevelPercent = {"_p_FIX__RelationshipRiskWarningLevelPercent", "FIX::RelationshipRiskWarningLevelPercent *", 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__RequestedPartyRole = {"_p_FIX__RequestedPartyRole", "FIX::RequestedPartyRole *", 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__RiskCFICode = {"_p_FIX__RiskCFICode", "FIX::RiskCFICode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskCouponRate = {"_p_FIX__RiskCouponRate", "FIX::RiskCouponRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskEncodedSecurityDesc = {"_p_FIX__RiskEncodedSecurityDesc", "FIX::RiskEncodedSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskEncodedSecurityDescLen = {"_p_FIX__RiskEncodedSecurityDescLen", "FIX::RiskEncodedSecurityDescLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskFlexibleIndicator = {"_p_FIX__RiskFlexibleIndicator", "FIX::RiskFlexibleIndicator *", 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__RiskInstrumentMultiplier = {"_p_FIX__RiskInstrumentMultiplier", "FIX::RiskInstrumentMultiplier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskInstrumentOperator = {"_p_FIX__RiskInstrumentOperator", "FIX::RiskInstrumentOperator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskInstrumentSettlType = {"_p_FIX__RiskInstrumentSettlType", "FIX::RiskInstrumentSettlType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskLimitAmount = {"_p_FIX__RiskLimitAmount", "FIX::RiskLimitAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskLimitCurrency = {"_p_FIX__RiskLimitCurrency", "FIX::RiskLimitCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskLimitPlatform = {"_p_FIX__RiskLimitPlatform", "FIX::RiskLimitPlatform *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskLimitType = {"_p_FIX__RiskLimitType", "FIX::RiskLimitType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskMaturityMonthYear = {"_p_FIX__RiskMaturityMonthYear", "FIX::RiskMaturityMonthYear *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskMaturityTime = {"_p_FIX__RiskMaturityTime", "FIX::RiskMaturityTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskProduct = {"_p_FIX__RiskProduct", "FIX::RiskProduct *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskProductComplex = {"_p_FIX__RiskProductComplex", "FIX::RiskProductComplex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskPutOrCall = {"_p_FIX__RiskPutOrCall", "FIX::RiskPutOrCall *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskRestructuringType = {"_p_FIX__RiskRestructuringType", "FIX::RiskRestructuringType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskSecurityAltID = {"_p_FIX__RiskSecurityAltID", "FIX::RiskSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskSecurityAltIDSource = {"_p_FIX__RiskSecurityAltIDSource", "FIX::RiskSecurityAltIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskSecurityDesc = {"_p_FIX__RiskSecurityDesc", "FIX::RiskSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskSecurityExchange = {"_p_FIX__RiskSecurityExchange", "FIX::RiskSecurityExchange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskSecurityGroup = {"_p_FIX__RiskSecurityGroup", "FIX::RiskSecurityGroup *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskSecurityID = {"_p_FIX__RiskSecurityID", "FIX::RiskSecurityID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskSecurityIDSource = {"_p_FIX__RiskSecurityIDSource", "FIX::RiskSecurityIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskSecuritySubType = {"_p_FIX__RiskSecuritySubType", "FIX::RiskSecuritySubType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskSecurityType = {"_p_FIX__RiskSecurityType", "FIX::RiskSecurityType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskSeniority = {"_p_FIX__RiskSeniority", "FIX::RiskSeniority *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskSymbol = {"_p_FIX__RiskSymbol", "FIX::RiskSymbol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskSymbolSfx = {"_p_FIX__RiskSymbolSfx", "FIX::RiskSymbolSfx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskWarningLevelName = {"_p_FIX__RiskWarningLevelName", "FIX::RiskWarningLevelName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskWarningLevelPercent = {"_p_FIX__RiskWarningLevelPercent", "FIX::RiskWarningLevelPercent *", 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__SecDefStatus = {"_p_FIX__SecDefStatus", "FIX::SecDefStatus *", 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::StringField *|FIX::TzTimeStampField *", 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__TotNoPartyList = {"_p_FIX__TotNoPartyList", "FIX::TotNoPartyList *", 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__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__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 *|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", "StringField *|TzTimeStampField *", 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__setTFIX__SessionID_t = {"_p_std__setTFIX__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__vectorTstd__string_t = {"_p_std__vectorTstd__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_DateTime,
  &_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__AsgnReqID,
  &_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__ContextPartyID,
  &_swigt__p_FIX__ContextPartyIDSource,
  &_swigt__p_FIX__ContextPartyRole,
  &_swigt__p_FIX__ContextPartySubID,
  &_swigt__p_FIX__ContextPartySubIDType,
  &_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__DerivativeSecurityListRequestType,
  &_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__EncodedSymbol,
  &_swigt__p_FIX__EncodedSymbolLen,
  &_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__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__NoContextPartyIDs,
  &_swigt__p_FIX__NoContextPartySubIDs,
  &_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__NoPartyAltIDs,
  &_swigt__p_FIX__NoPartyAltSubIDs,
  &_swigt__p_FIX__NoPartyIDs,
  &_swigt__p_FIX__NoPartyList,
  &_swigt__p_FIX__NoPartyListResponseTypes,
  &_swigt__p_FIX__NoPartyRelationships,
  &_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__NoRelatedContextPartyIDs,
  &_swigt__p_FIX__NoRelatedContextPartySubIDs,
  &_swigt__p_FIX__NoRelatedPartyAltIDs,
  &_swigt__p_FIX__NoRelatedPartyAltSubIDs,
  &_swigt__p_FIX__NoRelatedPartyIDs,
  &_swigt__p_FIX__NoRelatedPartySubIDs,
  &_swigt__p_FIX__NoRelatedSym,
  &_swigt__p_FIX__NoRelationshipRiskInstruments,
  &_swigt__p_FIX__NoRelationshipRiskLimits,
  &_swigt__p_FIX__NoRelationshipRiskSecurityAltID,
  &_swigt__p_FIX__NoRelationshipRiskWarningLevels,
  &_swigt__p_FIX__NoRequestedPartyRoles,
  &_swigt__p_FIX__NoRiskInstruments,
  &_swigt__p_FIX__NoRiskLimits,
  &_swigt__p_FIX__NoRiskSecurityAltID,
  &_swigt__p_FIX__NoRiskWarningLevels,
  &_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__PartyAltID,
  &_swigt__p_FIX__PartyAltIDSource,
  &_swigt__p_FIX__PartyAltSubID,
  &_swigt__p_FIX__PartyAltSubIDType,
  &_swigt__p_FIX__PartyDetailsListReportID,
  &_swigt__p_FIX__PartyDetailsListRequestID,
  &_swigt__p_FIX__PartyDetailsRequestResult,
  &_swigt__p_FIX__PartyID,
  &_swigt__p_FIX__PartyIDSource,
  &_swigt__p_FIX__PartyListResponseType,
  &_swigt__p_FIX__PartyRelationship,
  &_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__RelatedContextPartyID,
  &_swigt__p_FIX__RelatedContextPartyIDSource,
  &_swigt__p_FIX__RelatedContextPartyRole,
  &_swigt__p_FIX__RelatedContextPartySubID,
  &_swigt__p_FIX__RelatedContextPartySubIDType,
  &_swigt__p_FIX__RelatedPartyAltID,
  &_swigt__p_FIX__RelatedPartyAltIDSource,
  &_swigt__p_FIX__RelatedPartyAltSubID,
  &_swigt__p_FIX__RelatedPartyAltSubIDType,
  &_swigt__p_FIX__RelatedPartyID,
  &_swigt__p_FIX__RelatedPartyIDSource,
  &_swigt__p_FIX__RelatedPartyRole,
  &_swigt__p_FIX__RelatedPartySubID,
  &_swigt__p_FIX__RelatedPartySubIDType,
  &_swigt__p_FIX__RelationshipRiskCFICode,
  &_swigt__p_FIX__RelationshipRiskCouponRate,
  &_swigt__p_FIX__RelationshipRiskEncodedSecurityDesc,
  &_swigt__p_FIX__RelationshipRiskEncodedSecurityDescLen,
  &_swigt__p_FIX__RelationshipRiskFlexibleIndicator,
  &_swigt__p_FIX__RelationshipRiskInstrumentMultiplier,
  &_swigt__p_FIX__RelationshipRiskInstrumentOperator,
  &_swigt__p_FIX__RelationshipRiskInstrumentSettlType,
  &_swigt__p_FIX__RelationshipRiskLimitAmount,
  &_swigt__p_FIX__RelationshipRiskLimitCurrency,
  &_swigt__p_FIX__RelationshipRiskLimitPlatform,
  &_swigt__p_FIX__RelationshipRiskLimitType,
  &_swigt__p_FIX__RelationshipRiskMaturityMonthYear,
  &_swigt__p_FIX__RelationshipRiskMaturityTime,
  &_swigt__p_FIX__RelationshipRiskProduct,
  &_swigt__p_FIX__RelationshipRiskProductComplex,
  &_swigt__p_FIX__RelationshipRiskPutOrCall,
  &_swigt__p_FIX__RelationshipRiskRestructuringType,
  &_swigt__p_FIX__RelationshipRiskSecurityAltID,
  &_swigt__p_FIX__RelationshipRiskSecurityAltIDSource,
  &_swigt__p_FIX__RelationshipRiskSecurityDesc,
  &_swigt__p_FIX__RelationshipRiskSecurityExchange,
  &_swigt__p_FIX__RelationshipRiskSecurityGroup,
  &_swigt__p_FIX__RelationshipRiskSecurityID,
  &_swigt__p_FIX__RelationshipRiskSecurityIDSource,
  &_swigt__p_FIX__RelationshipRiskSecuritySubType,
  &_swigt__p_FIX__RelationshipRiskSecurityType,
  &_swigt__p_FIX__RelationshipRiskSeniority,
  &_swigt__p_FIX__RelationshipRiskSymbol,
  &_swigt__p_FIX__RelationshipRiskSymbolSfx,
  &_swigt__p_FIX__RelationshipRiskWarningLevelName,
  &_swigt__p_FIX__RelationshipRiskWarningLevelPercent,
  &_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__RequestedPartyRole,
  &_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__RiskCFICode,
  &_swigt__p_FIX__RiskCouponRate,
  &_swigt__p_FIX__RiskEncodedSecurityDesc,
  &_swigt__p_FIX__RiskEncodedSecurityDescLen,
  &_swigt__p_FIX__RiskFlexibleIndicator,
  &_swigt__p_FIX__RiskFreeRate,
  &_swigt__p_FIX__RiskInstrumentMultiplier,
  &_swigt__p_FIX__RiskInstrumentOperator,
  &_swigt__p_FIX__RiskInstrumentSettlType,
  &_swigt__p_FIX__RiskLimitAmount,
  &_swigt__p_FIX__RiskLimitCurrency,
  &_swigt__p_FIX__RiskLimitPlatform,
  &_swigt__p_FIX__RiskLimitType,
  &_swigt__p_FIX__RiskMaturityMonthYear,
  &_swigt__p_FIX__RiskMaturityTime,
  &_swigt__p_FIX__RiskProduct,
  &_swigt__p_FIX__RiskProductComplex,
  &_swigt__p_FIX__RiskPutOrCall,
  &_swigt__p_FIX__RiskRestructuringType,
  &_swigt__p_FIX__RiskSecurityAltID,
  &_swigt__p_FIX__RiskSecurityAltIDSource,
  &_swigt__p_FIX__RiskSecurityDesc,
  &_swigt__p_FIX__RiskSecurityExchange,
  &_swigt__p_FIX__RiskSecurityGroup,
  &_swigt__p_FIX__RiskSecurityID,
  &_swigt__p_FIX__RiskSecurityIDSource,
  &_swigt__p_FIX__RiskSecuritySubType,
  &_swigt__p_FIX__RiskSecurityType,
  &_swigt__p_FIX__RiskSeniority,
  &_swigt__p_FIX__RiskSymbol,
  &_swigt__p_FIX__RiskSymbolSfx,
  &_swigt__p_FIX__RiskWarningLevelName,
  &_swigt__p_FIX__RiskWarningLevelPercent,
  &_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__SecDefStatus,
  &_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__TotNoPartyList,
  &_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__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__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__setTFIX__SessionID_t,
  &_swigt__p_std__string,
  &_swigt__p_std__string__size_type,
  &_swigt__p_std__vectorTstd__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_DateTime[] = {  {&_swigt__p_DateTime, 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__AsgnReqID[] = {  {&_swigt__p_FIX__AsgnReqID, 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__WorkingIndicator, _p_FIX__WorkingIndicatorTo_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__RiskFlexibleIndicator, _p_FIX__RiskFlexibleIndicatorTo_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__LateIndicator, _p_FIX__LateIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__FlexibleIndicator, _p_FIX__FlexibleIndicatorTo_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__RelationshipRiskFlexibleIndicator, _p_FIX__RelationshipRiskFlexibleIndicatorTo_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__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__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__SettlInstTransType, _p_FIX__SettlInstTransTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__RegistTransType, _p_FIX__RegistTransTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__IOITransType, _p_FIX__IOITransTypeTo_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__TriggerPriceDirection, _p_FIX__TriggerPriceDirectionTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TickDirection, _p_FIX__TickDirectionTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__RoundingDirection, _p_FIX__RoundingDirectionTo_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__RelatedContextPartyIDSource, _p_FIX__RelatedContextPartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartyIDSource, _p_FIX__UnderlyingInstrumentPartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartyIDSource, _p_FIX__UndlyInstrumentPartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__RelatedPartyIDSource, _p_FIX__RelatedPartyIDSourceTo_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__PartyAltIDSource, _p_FIX__PartyAltIDSourceTo_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__ContextPartyIDSource, _p_FIX__ContextPartyIDSourceTo_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__RelatedPartyAltIDSource, _p_FIX__RelatedPartyAltIDSourceTo_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__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__DerivativeOptAttribute, _p_FIX__DerivativeOptAttributeTo_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__ContextPartyID[] = {  {&_swigt__p_FIX__ContextPartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContextPartyIDSource[] = {  {&_swigt__p_FIX__ContextPartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContextPartyRole[] = {  {&_swigt__p_FIX__ContextPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContextPartySubID[] = {  {&_swigt__p_FIX__ContextPartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContextPartySubIDType[] = {  {&_swigt__p_FIX__ContextPartySubIDType, 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__DerivativeSecurityListRequestType[] = {  {&_swigt__p_FIX__DerivativeSecurityListRequestType, 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__RiskLimitAmount, _p_FIX__RiskLimitAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeMinPriceIncrementAmount, _p_FIX__DerivativeMinPriceIncrementAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskLimitAmount, _p_FIX__RelationshipRiskLimitAmountTo_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__FeeMultiplier, _p_FIX__FeeMultiplierTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingContractMultiplier, _p_FIX__UnderlyingContractMultiplierTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegContractMultiplier, _p_FIX__LegContractMultiplierTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ContractMultiplier, _p_FIX__ContractMultiplierTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__StrikeMultiplier, _p_FIX__StrikeMultiplierTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeStrikeMultiplier, _p_FIX__DerivativeStrikeMultiplierTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeContractMultiplier, _p_FIX__DerivativeContractMultiplierTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskInstrumentMultiplier, _p_FIX__RelationshipRiskInstrumentMultiplierTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RiskInstrumentMultiplier, _p_FIX__RiskInstrumentMultiplierTo_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__SideGrossTradeAmt, _p_FIX__SideGrossTradeAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__GrossTradeAmt, _p_FIX__GrossTradeAmtTo_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__BuyVolume, _p_FIX__BuyVolumeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TradeVolume, _p_FIX__TradeVolumeTo_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__RiskCouponRate, _p_FIX__RiskCouponRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskCouponRate, _p_FIX__RelationshipRiskCouponRateTo_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__SecondaryHighLimitPrice, _p_FIX__SecondaryHighLimitPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__HighLimitPrice, _p_FIX__HighLimitPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SecondaryLowLimitPrice, _p_FIX__SecondaryLowLimitPriceTo_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__RiskWarningLevelPercent, _p_FIX__RiskWarningLevelPercentTo_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__RelationshipRiskWarningLevelPercent, _p_FIX__RelationshipRiskWarningLevelPercentTo_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__EncodedSymbol[] = {  {&_swigt__p_FIX__EncodedSymbol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedSymbolLen[] = {  {&_swigt__p_FIX__EncodedSymbolLen, 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__RiskCFICode, _p_FIX__RiskCFICodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskCFICode, _p_FIX__RelationshipRiskCFICodeTo_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__DerivativePriceUnitOfMeasure, _p_FIX__DerivativePriceUnitOfMeasureTo_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__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__DerivativeSecurityType, _p_FIX__DerivativeSecurityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuantityType, _p_FIX__QuantityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSecurityType, _p_FIX__LegSecurityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityType, _p_FIX__UnderlyingLegSecurityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSecurityType, _p_FIX__RelationshipRiskSecurityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QtyType, _p_FIX__QtyTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingRepoCollateralSecurityType, _p_FIX__UnderlyingRepoCollateralSecurityTypeTo_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__RiskSecurityType, _p_FIX__RiskSecurityTypeTo_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__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__RiskSecuritySubType, _p_FIX__RiskSecuritySubTypeTo_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__RelationshipRiskSecuritySubType, _p_FIX__RelationshipRiskSecuritySubTypeTo_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__TradeRequestID, _p_FIX__TradeRequestIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UserRequestID, _p_FIX__UserRequestIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PartyDetailsListRequestID, _p_FIX__PartyDetailsListRequestIDTo_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__CalculatedCcyLastQty, _p_FIX__CalculatedCcyLastQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastQty, _p_FIX__LastQtyTo_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__UnderlyingLastQty, _p_FIX__UnderlyingLastQtyTo_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__RiskLimitType, _p_FIX__RiskLimitTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegLimitType, _p_FIX__PegLimitTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskLimitType, _p_FIX__RelationshipRiskLimitTypeTo_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__SpreadToBenchmark, _p_FIX__SpreadToBenchmarkTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Benchmark, _p_FIX__BenchmarkTo_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__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__CollAsgnReason, _p_FIX__CollAsgnReasonTo_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__NoUnderlyings, _p_FIX__NoUnderlyingsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoOfLegUnderlyings, _p_FIX__NoOfLegUnderlyingsTo_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__SymbolSfx, _p_FIX__SymbolSfxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSymbolSfx, _p_FIX__UnderlyingLegSymbolSfxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskSymbolSfx, _p_FIX__RiskSymbolSfxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSymbolSfx, _p_FIX__DerivativeSymbolSfxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSymbolSfx, _p_FIX__UnderlyingSymbolSfxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSymbolSfx, _p_FIX__LegSymbolSfxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSymbolSfx, _p_FIX__RelationshipRiskSymbolSfxTo_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__PositionCurrency, _p_FIX__PositionCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCurrency, _p_FIX__UnderlyingCurrencyTo_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__RiskLimitCurrency, _p_FIX__RiskLimitCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskLimitCurrency, _p_FIX__RelationshipRiskLimitCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegStrikeCurrency, _p_FIX__LegStrikeCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidTradeType, _p_FIX__BidTradeTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeType, _p_FIX__TradeTypeTo_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__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__UnderlyingStateOrProvinceOfIssue, _p_FIX__UnderlyingStateOrProvinceOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeCountryOfIssue, _p_FIX__DerivativeCountryOfIssueTo_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__LegLocaleOfIssue, _p_FIX__LegLocaleOfIssueTo_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__RelationshipRiskSeniority, _p_FIX__RelationshipRiskSeniorityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskSeniority, _p_FIX__RiskSeniorityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSeniority, _p_FIX__UnderlyingSeniorityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Seniority, _p_FIX__SeniorityTo_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__PartyDetailsListReportID, _p_FIX__PartyDetailsListReportIDTo_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__RelationshipRiskInstrumentSettlType, _p_FIX__RelationshipRiskInstrumentSettlTypeTo_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__RiskInstrumentSettlType, _p_FIX__RiskInstrumentSettlTypeTo_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__RiskWarningLevelPercent, _p_FIX__RiskWarningLevelPercentTo_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__RelationshipRiskWarningLevelPercent, _p_FIX__RelationshipRiskWarningLevelPercentTo_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__DerivativeEventTime, _p_FIX__DerivativeEventTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EventTime, _p_FIX__EventTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContextPartyRole, _p_FIX__ContextPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RootPartyRole, _p_FIX__RootPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartyRole, _p_FIX__UndlyInstrumentPartyRoleTo_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__RequestedPartyRole, _p_FIX__RequestedPartyRoleTo_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__RelatedPartyRole, _p_FIX__RelatedPartyRoleTo_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__RelatedContextPartyRole, _p_FIX__RelatedContextPartyRoleTo_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__CashDistribAgentCode, _p_FIX__CashDistribAgentCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentCode, _p_FIX__SecuritySettlAgentCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashSettlAgentCode, _p_FIX__CashSettlAgentCodeTo_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__SecurityResponseID, _p_FIX__SecurityResponseIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastNetworkResponseID, _p_FIX__LastNetworkResponseIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NetworkResponseID, _p_FIX__NetworkResponseIDTo_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__TriggerPrice, _p_FIX__TriggerPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FloorPrice, _p_FIX__FloorPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeFloorPrice, _p_FIX__DerivativeFloorPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PutOrCall, _p_FIX__PutOrCallTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskPutOrCall, _p_FIX__RiskPutOrCallTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegPutOrCall, _p_FIX__LegPutOrCallTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegPutOrCall, _p_FIX__UnderlyingLegPutOrCallTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativePutOrCall, _p_FIX__DerivativePutOrCallTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskPutOrCall, _p_FIX__RelationshipRiskPutOrCallTo_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__TradeCondition, _p_FIX__TradeConditionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexEventCondition, _p_FIX__ComplexEventConditionTo_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__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__RelationshipRiskSecurityAltIDSource, _p_FIX__RelationshipRiskSecurityAltIDSourceTo_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__ContextPartyIDSource, _p_FIX__ContextPartyIDSourceTo_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__RiskSecurityAltIDSource, _p_FIX__RiskSecurityAltIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoAltMDSource, _p_FIX__NoAltMDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSecurityIDSource, _p_FIX__RelationshipRiskSecurityIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelatedContextPartyIDSource, _p_FIX__RelatedContextPartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MessageEventSource, _p_FIX__MessageEventSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartyIDSource, _p_FIX__UndlyInstrumentPartyIDSourceTo_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__RiskSecurityIDSource, _p_FIX__RiskSecurityIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RootPartyIDSource, _p_FIX__RootPartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PartyAltIDSource, _p_FIX__PartyAltIDSourceTo_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__RelatedPartyIDSource, _p_FIX__RelatedPartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocAcctIDSource, _p_FIX__AllocAcctIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlPartyIDSource, _p_FIX__SettlPartyIDSourceTo_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__RelatedPartyAltIDSource, _p_FIX__RelatedPartyAltIDSourceTo_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__NewPassword, _p_FIX__NewPasswordTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncryptedNewPassword, _p_FIX__EncryptedNewPasswordTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PartyRelationship, _p_FIX__PartyRelationshipTo_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__UnderlyingSymbol, _p_FIX__UnderlyingSymbolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskSymbol, _p_FIX__RiskSymbolTo_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__LegSymbol, _p_FIX__LegSymbolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSymbol, _p_FIX__DerivativeSymbolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSymbol, _p_FIX__RelationshipRiskSymbolTo_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__PartyAltSubID, _p_FIX__PartyAltSubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelatedPartyAltSubID, _p_FIX__RelatedPartyAltSubIDTo_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__LegInterestAccrualDate, _p_FIX__LegInterestAccrualDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InterestAccrualDate, _p_FIX__InterestAccrualDateTo_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__RiskInstrumentOperator, _p_FIX__RiskInstrumentOperatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskInstrumentOperator, _p_FIX__RelationshipRiskInstrumentOperatorTo_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__EncodedSymbol, _p_FIX__EncodedSymbolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoPartyRelationships, _p_FIX__NoPartyRelationshipsTo_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__Subject, _p_FIX__SubjectTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedSubject, _p_FIX__EncodedSubjectTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeLinkID, _p_FIX__TradeLinkIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocLinkID, _p_FIX__AllocLinkIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegBidPx, _p_FIX__LegBidPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoOrdTypeRules, _p_FIX__NoOrdTypeRulesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoLotTypeRules, _p_FIX__NoLotTypeRulesTo_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__ExecPriceAdjustment, _p_FIX__ExecPriceAdjustmentTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Adjustment, _p_FIX__AdjustmentTo_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__OfferPx, _p_FIX__OfferPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MktOfferPx, _p_FIX__MktOfferPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegOfferPx, _p_FIX__LegOfferPxTo_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__MDEntrySpotRate, _p_FIX__MDEntrySpotRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidSpotRate, _p_FIX__BidSpotRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OfferSpotRate, _p_FIX__OfferSpotRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastSpotRate, _p_FIX__LastSpotRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityXMLSchema, _p_FIX__SecurityXMLSchemaTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityXMLSchema, _p_FIX__DerivativeSecurityXMLSchemaTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlInstCode, _p_FIX__SettlInstCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NumDaysInterest, _p_FIX__NumDaysInterestTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OpenInterest, _p_FIX__OpenInterestTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideValueInd, _p_FIX__SideValueIndTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskMaturityMonthYear, _p_FIX__RiskMaturityMonthYearTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskMaturityMonthYear, _p_FIX__RelationshipRiskMaturityMonthYearTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegMaturityMonthYear, _p_FIX__LegMaturityMonthYearTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StartMaturityMonthYear, _p_FIX__StartMaturityMonthYearTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaturityMonthYear, _p_FIX__MaturityMonthYearTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeMaturityMonthYear, _p_FIX__DerivativeMaturityMonthYearTo_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__UnderlyingLegMaturityMonthYear, _p_FIX__UnderlyingLegMaturityMonthYearTo_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__TotNoPartyList, _p_FIX__TotNoPartyListTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoPartyList, _p_FIX__NoPartyListTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoSettlOblig, _p_FIX__NoSettlObligTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskSecurityAltID, _p_FIX__RiskSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRiskSecurityAltID, _p_FIX__NoRiskSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoUnderlyingLegSecurityAltID, _p_FIX__NoUnderlyingLegSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRelationshipRiskSecurityAltID, _p_FIX__NoRelationshipRiskSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityAltID, _p_FIX__UnderlyingSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityAltID, _p_FIX__DerivativeSecurityAltIDTo_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__SecurityAltID, _p_FIX__SecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoLegSecurityAltID, _p_FIX__NoLegSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSecurityAltID, _p_FIX__RelationshipRiskSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelatedPartyAltID, _p_FIX__RelatedPartyAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoSecurityAltID, _p_FIX__NoSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PartyAltID, _p_FIX__PartyAltIDTo_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__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__ExecInst, _p_FIX__ExecInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedListExecInst, _p_FIX__EncodedListExecInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegExecInst, _p_FIX__LegExecInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListExecInst, _p_FIX__ListExecInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoLinesOfText, _p_FIX__NoLinesOfTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LinesOfText, _p_FIX__LinesOfTextTo_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__NoStrikeRules, _p_FIX__NoStrikeRulesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoTimeInForceRules, _p_FIX__NoTimeInForceRulesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegBenchmarkPrice, _p_FIX__LegBenchmarkPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BenchmarkPrice, _p_FIX__BenchmarkPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DueToRelated, _p_FIX__DueToRelatedTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DlvyInst, _p_FIX__DlvyInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoDlvyInst, _p_FIX__NoDlvyInstTo_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__EndTickPriceRange, _p_FIX__EndTickPriceRangeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StartTickPriceRange, _p_FIX__StartTickPriceRangeTo_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__MinPriceIncrement, _p_FIX__MinPriceIncrementTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeMinPriceIncrement, _p_FIX__DerivativeMinPriceIncrementTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikeIncrement, _p_FIX__StrikeIncrementTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MatchIncrement, _p_FIX__MatchIncrementTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaturityMonthYearIncrement, _p_FIX__MaturityMonthYearIncrementTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TickIncrement, _p_FIX__TickIncrementTo_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__EventText, _p_FIX__EventTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeEventText, _p_FIX__DerivativeEventTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlInstReqRejCode, _p_FIX__SettlInstReqRejCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocRejCode, _p_FIX__AllocRejCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IndividualAllocRejCode, _p_FIX__IndividualAllocRejCodeTo_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__TransactTime, _p_FIX__TransactTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TZTransactTime, _p_FIX__TZTransactTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelSymTransactTime, _p_FIX__RelSymTransactTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingPriceUnitOfMeasureQty, _p_FIX__UnderlyingPriceUnitOfMeasureQtyTo_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__UnderlyingUnitOfMeasureQty, _p_FIX__UnderlyingUnitOfMeasureQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnitOfMeasureQty, _p_FIX__UnitOfMeasureQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegPriceUnitOfMeasureQty, _p_FIX__LegPriceUnitOfMeasureQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriceUnitOfMeasureQty, _p_FIX__PriceUnitOfMeasureQtyTo_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__TotNoAllocs, _p_FIX__TotNoAllocsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoLegAllocs, _p_FIX__NoLegAllocsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoAllocs, _p_FIX__NoAllocsTo_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__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__DeskOrderHandlingInst, _p_FIX__DeskOrderHandlingInstTo_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__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__DerivativeOptAttribute, _p_FIX__DerivativeOptAttributeTo_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__AsgnReqID, _p_FIX__AsgnReqIDTo_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__RelationshipRiskRestructuringType, _p_FIX__RelationshipRiskRestructuringTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RestructuringType, _p_FIX__RestructuringTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskRestructuringType, _p_FIX__RiskRestructuringTypeTo_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__SecurityListID, _p_FIX__SecurityListIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListID, _p_FIX__ListIDTo_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__TotalNumSecurityTypes, _p_FIX__TotalNumSecurityTypesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoMDEntryTypes, _p_FIX__NoMDEntryTypesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoSecurityTypes, _p_FIX__NoSecurityTypesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRiskWarningLevels, _p_FIX__NoRiskWarningLevelsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRelationshipRiskWarningLevels, _p_FIX__NoRelationshipRiskWarningLevelsTo_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__DerivativeSecurityListRequestType, _p_FIX__DerivativeSecurityListRequestTypeTo_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__RelationshipRiskProductComplex, _p_FIX__RelationshipRiskProductComplexTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskProductComplex, _p_FIX__RiskProductComplexTo_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__ComplianceID, _p_FIX__ComplianceIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideComplianceID, _p_FIX__SideComplianceIDTo_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__RelatedPartySubID, _p_FIX__RelatedPartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelatedContextPartySubID, _p_FIX__RelatedContextPartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InstrumentPartySubID, _p_FIX__InstrumentPartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContextPartySubID, _p_FIX__ContextPartySubIDTo_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__StreamAsgnRptID, _p_FIX__StreamAsgnRptIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AsgnRptID, _p_FIX__AsgnRptIDTo_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__SecondaryExecID, _p_FIX__SecondaryExecIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecID, _p_FIX__ExecIDTo_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__EncodedUnderlyingSecurityDescLen, _p_FIX__EncodedUnderlyingSecurityDescLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskEncodedSecurityDescLen, _p_FIX__RelationshipRiskEncodedSecurityDescLenTo_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__EncodedSecurityListDescLen, _p_FIX__EncodedSecurityListDescLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedSecurityDescLen, _p_FIX__EncodedSecurityDescLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskEncodedSecurityDescLen, _p_FIX__RiskEncodedSecurityDescLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntryOriginator, _p_FIX__MDEntryOriginatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegFutSettDate, _p_FIX__LegFutSettDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FutSettDate, _p_FIX__FutSettDateTo_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__NoPartyListResponseTypes, _p_FIX__NoPartyListResponseTypesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested2PartyID, _p_FIX__Nested2PartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InstrumentPartyID, _p_FIX__InstrumentPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeInstrumentPartyID, _p_FIX__DerivativeInstrumentPartyIDTo_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__RelatedContextPartyID, _p_FIX__RelatedContextPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartyID, _p_FIX__UnderlyingInstrumentPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NestedPartyID, _p_FIX__NestedPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelatedPartyID, _p_FIX__RelatedPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested3PartyID, _p_FIX__Nested3PartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlPartyID, _p_FIX__SettlPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContextPartyID, _p_FIX__ContextPartyIDTo_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__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__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__RiskFlexibleIndicator, _p_FIX__RiskFlexibleIndicatorTo_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__RelationshipRiskFlexibleIndicator, _p_FIX__RelationshipRiskFlexibleIndicatorTo_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__PriorSpreadIndicator, _p_FIX__PriorSpreadIndicatorTo_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__TradeReportRefID, _p_FIX__TradeReportRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocReportRefID, _p_FIX__AllocReportRefIDTo_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__UnderlyingSettlPrice, _p_FIX__UnderlyingSettlPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlPrice, _p_FIX__SettlPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriorSettlPrice, _p_FIX__PriorSettlPriceTo_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__MassStatusReqType, _p_FIX__MassStatusReqTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosReqType, _p_FIX__PosReqTypeTo_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__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__RelationshipRiskSecurityExchange, _p_FIX__RelationshipRiskSecurityExchangeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskSecurityExchange, _p_FIX__RiskSecurityExchangeTo_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__RelatedPartyAltSubIDType, _p_FIX__RelatedPartyAltSubIDTypeTo_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__PartyAltSubIDType, _p_FIX__PartyAltSubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelatedPartySubIDType, _p_FIX__RelatedPartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContextPartySubIDType, _p_FIX__ContextPartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelatedContextPartySubIDType, _p_FIX__RelatedContextPartySubIDTypeTo_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__DatedDate, _p_FIX__DatedDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegDatedDate, _p_FIX__LegDatedDateTo_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__RiskCouponRate, _p_FIX__RiskCouponRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskCouponRate, _p_FIX__RelationshipRiskCouponRateTo_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__DerivativeExerciseStyle, _p_FIX__DerivativeExerciseStyleTo_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__ExerciseStyle, _p_FIX__ExerciseStyleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikeExerciseStyle, _p_FIX__StrikeExerciseStyleTo_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__DerivativeEncodedIssuer, _p_FIX__DerivativeEncodedIssuerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedIssuer, _p_FIX__EncodedIssuerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoAsgnReqs, _p_FIX__NoAsgnReqsTo_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__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__OrdStatusReqID, _p_FIX__OrdStatusReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteStatusReqID, _p_FIX__QuoteStatusReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContingencyType, _p_FIX__ContingencyTypeTo_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__NoFills, _p_FIX__NoFillsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoFills, _p_FIX__TotNoFillsTo_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__QuoteRespType, _p_FIX__QuoteRespTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollAsgnRespType, _p_FIX__CollAsgnRespTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ParticipationRate, _p_FIX__ParticipationRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BuyVolume, _p_FIX__BuyVolumeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeVolume, _p_FIX__TradeVolumeTo_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__NoRelatedPartyAltIDs, _p_FIX__NoRelatedPartyAltIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoPartyAltIDs, _p_FIX__NoPartyAltIDsTo_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__UnderlyingStipValue, _p_FIX__UnderlyingStipValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__HeartBtInt, _p_FIX__HeartBtIntTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCapValue, _p_FIX__UnderlyingCapValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncryptedPasswordLen, _p_FIX__EncryptedPasswordLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncryptedNewPasswordLen, _p_FIX__EncryptedNewPasswordLenTo_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__RiskInstrumentMultiplier, _p_FIX__RiskInstrumentMultiplierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FeeMultiplier, _p_FIX__FeeMultiplierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskInstrumentMultiplier, _p_FIX__RelationshipRiskInstrumentMultiplierTo_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__ApplNewSeqNum, _p_FIX__ApplNewSeqNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NextExpectedMsgSeqNum, _p_FIX__NextExpectedMsgSeqNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MsgSeqNum, _p_FIX__MsgSeqNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplBegSeqNum, _p_FIX__ApplBegSeqNumTo_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__PartyListResponseType, _p_FIX__PartyListResponseTypeTo_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__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__RelationshipRiskSecurityDesc, _p_FIX__RelationshipRiskSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedSecurityDesc, _p_FIX__EncodedSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityDesc, _p_FIX__UnderlyingSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskEncodedSecurityDesc, _p_FIX__RiskEncodedSecurityDescTo_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__DerivativeEncodedSecurityDesc, _p_FIX__DerivativeEncodedSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSecurityDesc, _p_FIX__LegSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskEncodedSecurityDesc, _p_FIX__RelationshipRiskEncodedSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskSecurityDesc, _p_FIX__RiskSecurityDescTo_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__EncodedSymbolLen, _p_FIX__EncodedSymbolLenTo_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__TargetStrategyParameters, _p_FIX__TargetStrategyParametersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoStrategyParameters, _p_FIX__NoStrategyParametersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoCapacities, _p_FIX__NoCapacitiesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRiskLimits, _p_FIX__NoRiskLimitsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRelationshipRiskLimits, _p_FIX__NoRelationshipRiskLimitsTo_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__DerivativeMaturityDate, _p_FIX__DerivativeMaturityDateTo_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__MaturityDate, _p_FIX__MaturityDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MsgDirection, _p_FIX__MsgDirectionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RoundingDirection, _p_FIX__RoundingDirectionTo_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__PegRoundDirection, _p_FIX__PegRoundDirectionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DiscretionRoundDirection, _p_FIX__DiscretionRoundDirectionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PossResend, _p_FIX__PossResendTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskSecurityGroup, _p_FIX__RiskSecurityGroupTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityGroup, _p_FIX__DerivativeSecurityGroupTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSecurityGroup, _p_FIX__RelationshipRiskSecurityGroupTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityGroup, _p_FIX__SecurityGroupTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RateSourceType, _p_FIX__RateSourceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoOrders, _p_FIX__NoOrdersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoOrders, _p_FIX__TotNoOrdersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollInquiryResult, _p_FIX__CollInquiryResultTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosReqResult, _p_FIX__PosReqResultTo_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__SecurityStatus, _p_FIX__SecurityStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityStatus, _p_FIX__DerivativeSecurityStatusTo_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__PosReqStatus, _p_FIX__PosReqStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocStatus, _p_FIX__AllocStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityTradingStatus, _p_FIX__SecurityTradingStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ConfirmStatus, _p_FIX__ConfirmStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteStatus, _p_FIX__QuoteStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosQtyStatus, _p_FIX__PosQtyStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AffirmStatus, _p_FIX__AffirmStatusTo_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__AllocNoOrdersType, _p_FIX__AllocNoOrdersTypeTo_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__ExecTransType, _p_FIX__ExecTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocTransType, _p_FIX__AllocTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidRequestTransType, _p_FIX__BidRequestTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlInstTransType, _p_FIX__SettlInstTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RegistTransType, _p_FIX__RegistTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IOITransType, _p_FIX__IOITransTypeTo_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__RelationshipRiskWarningLevelName, _p_FIX__RelationshipRiskWarningLevelNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskWarningLevelName, _p_FIX__RiskWarningLevelNameTo_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__NoUndlyInstrumentPartySubIDs, _p_FIX__NoUndlyInstrumentPartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRelatedContextPartySubIDs, _p_FIX__NoRelatedContextPartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNested2PartySubIDs, _p_FIX__NoNested2PartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRootPartySubIDs, _p_FIX__NoRootPartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNestedPartySubIDs, _p_FIX__NoNestedPartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNested4PartySubIDs, _p_FIX__NoNested4PartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNested3PartySubIDs, _p_FIX__NoNested3PartySubIDsTo_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__NoRelatedPartySubIDs, _p_FIX__NoRelatedPartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoContextPartySubIDs, _p_FIX__NoContextPartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoInstrumentPartySubIDs, _p_FIX__NoInstrumentPartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoPartySubIDs, _p_FIX__NoPartySubIDsTo_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__NoRequestedPartyRoles, _p_FIX__NoRequestedPartyRolesTo_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__StipulationType, _p_FIX__StipulationTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegStipulationType, _p_FIX__LegStipulationTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MassActionType, _p_FIX__MassActionTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TerminationType, _p_FIX__TerminationTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlObligID, _p_FIX__SettlObligIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NotAffOrigClOrdID, _p_FIX__NotAffOrigClOrdIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigClOrdID, _p_FIX__OrigClOrdIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ClOrdID, _p_FIX__ClOrdIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryClOrdID, _p_FIX__SecondaryClOrdIDTo_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__RndPx, _p_FIX__RndPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DayCumQty, _p_FIX__DayCumQtyTo_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__ExecPriceType, _p_FIX__ExecPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerPriceType, _p_FIX__TriggerPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlPriceType, _p_FIX__UnderlyingSettlPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegPriceType, _p_FIX__PegPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriceType, _p_FIX__PriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__YieldRedemptionPriceType, _p_FIX__YieldRedemptionPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuotePriceType, _p_FIX__QuotePriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegBenchmarkPriceType, _p_FIX__LegBenchmarkPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlPriceType, _p_FIX__SettlPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegPriceType, _p_FIX__LegPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BenchmarkPriceType, _p_FIX__BenchmarkPriceTypeTo_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__PartyDetailsRequestResult, _p_FIX__PartyDetailsRequestResultTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeRequestResult, _p_FIX__TradeRequestResultTo_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__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__BenchmarkSecurityID, _p_FIX__BenchmarkSecurityIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityID, _p_FIX__DerivativeSecurityIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegSecurityID, _p_FIX__PegSecurityIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskSecurityID, _p_FIX__RiskSecurityIDTo_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__RelationshipRiskSecurityID, _p_FIX__RelationshipRiskSecurityIDTo_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__PosMaintStatus, _p_FIX__PosMaintStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollStatus, _p_FIX__CollStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListOrderStatus, _p_FIX__ListOrderStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeRequestStatus, _p_FIX__TradeRequestStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SessionStatus, _p_FIX__SessionStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecDefStatus, _p_FIX__SecDefStatusTo_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__OrderAvgPx, _p_FIX__OrderAvgPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntryRefID, _p_FIX__MDEntryRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__XmlDataLen, _p_FIX__XmlDataLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecureDataLen, _p_FIX__SecureDataLenTo_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__RiskMaturityTime, _p_FIX__RiskMaturityTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeMaturityTime, _p_FIX__DerivativeMaturityTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskMaturityTime, _p_FIX__RelationshipRiskMaturityTimeTo_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__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__NoPartyAltSubIDs, _p_FIX__NoPartyAltSubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRelatedPartyAltSubIDs, _p_FIX__NoRelatedPartyAltSubIDsTo_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__UnderlyingPayAmount, _p_FIX__UnderlyingPayAmountTo_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__RiskLimitPlatform, _p_FIX__RiskLimitPlatformTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskLimitPlatform, _p_FIX__RelationshipRiskLimitPlatformTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoContAmts, _p_FIX__NoContAmtsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IndividualAllocType, _p_FIX__IndividualAllocTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocType, _p_FIX__AllocTypeTo_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__RelationshipRiskProduct, _p_FIX__RelationshipRiskProductTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskProduct, _p_FIX__RiskProductTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegProduct, _p_FIX__LegProductTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeProduct, _p_FIX__DerivativeProductTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingProduct, _p_FIX__UnderlyingProductTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Product, _p_FIX__ProductTo_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__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__ApplReqID, _p_FIX__ApplReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefApplReqID, _p_FIX__RefApplReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollReqID, _p_FIX__CollReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesMethod, _p_FIX__TradSesMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocMethod, _p_FIX__AllocMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexEventPriceBoundaryMethod, _p_FIX__ComplexEventPriceBoundaryMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MultilegPriceMethod, _p_FIX__MultilegPriceMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikePriceBoundaryMethod, _p_FIX__StrikePriceBoundaryMethodTo_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__OrigTradeDate, _p_FIX__OrigTradeDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeDate, _p_FIX__TradeDateTo_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__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__RelationshipRiskLimitAmount, _p_FIX__RelationshipRiskLimitAmountTo_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__RiskLimitAmount, _p_FIX__RiskLimitAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCashAmount, _p_FIX__UnderlyingCashAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MinPriceIncrementAmount, _p_FIX__MinPriceIncrementAmountTo_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__CrossID, _p_FIX__CrossIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigCrossID, _p_FIX__OrigCrossIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__HostCrossID, _p_FIX__HostCrossIDTo_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__NoRelatedContextPartyIDs, _p_FIX__NoRelatedContextPartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNested3PartyIDs, _p_FIX__NoNested3PartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoPartyIDs, _p_FIX__NoPartyIDsTo_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__NoSettlPartyIDs, _p_FIX__NoSettlPartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRelatedPartyIDs, _p_FIX__NoRelatedPartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNested2PartyIDs, _p_FIX__NoNested2PartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNestedPartyIDs, _p_FIX__NoNestedPartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoContextPartyIDs, _p_FIX__NoContextPartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNested4PartyIDs, _p_FIX__NoNested4PartyIDsTo_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__ComplexEventPriceBoundaryPrecision, _p_FIX__ComplexEventPriceBoundaryPrecisionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikePriceBoundaryPrecision, _p_FIX__StrikePriceBoundaryPrecisionTo_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__QuoteQualifier, _p_FIX__QuoteQualifierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IOIQualifier, _p_FIX__IOIQualifierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollInquiryQualifier, _p_FIX__CollInquiryQualifierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoCollInquiryQualifier, _p_FIX__NoCollInquiryQualifierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRiskInstruments, _p_FIX__NoRiskInstrumentsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRelationshipRiskInstruments, _p_FIX__NoRelationshipRiskInstrumentsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegGrossTradeAmt, _p_FIX__LegGrossTradeAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__GrossTradeAmt, _p_FIX__GrossTradeAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideGrossTradeAmt, _p_FIX__SideGrossTradeAmtTo_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__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__DerivativeListMethod, _p_FIX__DerivativeListMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncryptedPasswordMethod, _p_FIX__EncryptedPasswordMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DistribPaymentMethod, _p_FIX__DistribPaymentMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListMethod, _p_FIX__ListMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncryptMethod, _p_FIX__EncryptMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikePriceDeterminationMethod, _p_FIX__StrikePriceDeterminationMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PaymentMethod, _p_FIX__PaymentMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingPriceDeterminationMethod, _p_FIX__UnderlyingPriceDeterminationMethodTo_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__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__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__NoRelationshipRiskWarningLevels, _p_FIX__NoRelationshipRiskWarningLevelsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MaxPriceLevels, _p_FIX__MaxPriceLevelsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRiskWarningLevels, _p_FIX__NoRiskWarningLevelsTo_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__NoRelationshipRiskInstruments, _p_FIX__NoRelationshipRiskInstrumentsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRiskInstruments, _p_FIX__NoRiskInstrumentsTo_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__ApplNewSeqNum, _p_FIX__ApplNewSeqNumTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NextExpectedMsgSeqNum, _p_FIX__NextExpectedMsgSeqNumTo_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__OrdRejReason, _p_FIX__OrdRejReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ExecRestatementReason, _p_FIX__ExecRestatementReasonTo_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__AllocCancReplaceReason, _p_FIX__AllocCancReplaceReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ShortSaleReason, _p_FIX__ShortSaleReasonTo_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__RelationshipRiskLimitType, _p_FIX__RelationshipRiskLimitTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RiskLimitType, _p_FIX__RiskLimitTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PriceLimitType, _p_FIX__PriceLimitTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskInstrumentOperator, _p_FIX__RelationshipRiskInstrumentOperatorTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RiskInstrumentOperator, _p_FIX__RiskInstrumentOperatorTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskProduct, _p_FIX__RelationshipRiskProductTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RiskProduct, _p_FIX__RiskProductTo_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__NoDerivativeSecurityAltID, _p_FIX__NoDerivativeSecurityAltIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRelationshipRiskSecurityAltID, _p_FIX__NoRelationshipRiskSecurityAltIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoUnderlyingLegSecurityAltID, _p_FIX__NoUnderlyingLegSecurityAltIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRiskSecurityAltID, _p_FIX__NoRiskSecurityAltIDTo_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__DerivativeSecurityListRequestType, _p_FIX__DerivativeSecurityListRequestTypeTo_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__RiskPutOrCall, _p_FIX__RiskPutOrCallTo_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__RelationshipRiskPutOrCall, _p_FIX__RelationshipRiskPutOrCallTo_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__PriorityIndicator, _p_FIX__PriorityIndicatorTo_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__TradeAllocIndicator, _p_FIX__TradeAllocIndicatorTo_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__PosMaintStatus, _p_FIX__PosMaintStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CollStatus, _p_FIX__CollStatusTo_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__SecDefStatus, _p_FIX__SecDefStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StrikeExerciseStyle, _p_FIX__StrikeExerciseStyleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ExerciseStyle, _p_FIX__ExerciseStyleTo_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__AllocType, _p_FIX__AllocTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__IndividualAllocType, _p_FIX__IndividualAllocTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoComplexEventDates, _p_FIX__NoComplexEventDatesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteEntryStatus, _p_FIX__QuoteEntryStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CollInquiryStatus, _p_FIX__CollInquiryStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradSesStatus, _p_FIX__TradSesStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteAckStatus, _p_FIX__QuoteAckStatusTo_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__QuoteStatus, _p_FIX__QuoteStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ConfirmStatus, _p_FIX__ConfirmStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecurityTradingStatus, _p_FIX__SecurityTradingStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocStatus, _p_FIX__AllocStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PosReqStatus, _p_FIX__PosReqStatusTo_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__NoPartyRelationships, _p_FIX__NoPartyRelationshipsTo_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__ResponseTransportType, _p_FIX__ResponseTransportTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradeReportType, _p_FIX__TradeReportTypeTo_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__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__UnderlyingFlowScheduleType, _p_FIX__UnderlyingFlowScheduleTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TickRuleType, _p_FIX__TickRuleTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NestedPartyRole, _p_FIX__NestedPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RelatedPartyRole, _p_FIX__RelatedPartyRoleTo_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__Nested3PartyRole, _p_FIX__Nested3PartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RelatedContextPartyRole, _p_FIX__RelatedContextPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SettlPartyRole, _p_FIX__SettlPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__Nested4PartyRole, _p_FIX__Nested4PartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RequestedPartyRole, _p_FIX__RequestedPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__InstrumentPartyRole, _p_FIX__InstrumentPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TrdRepPartyRole, _p_FIX__TrdRepPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ContextPartyRole, _p_FIX__ContextPartyRoleTo_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__RelationshipRiskEncodedSecurityDescLen, _p_FIX__RelationshipRiskEncodedSecurityDescLenTo_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__RiskEncodedSecurityDescLen, _p_FIX__RiskEncodedSecurityDescLenTo_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__NoRelatedPartyAltSubIDs, _p_FIX__NoRelatedPartyAltSubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoPartyAltSubIDs, _p_FIX__NoPartyAltSubIDsTo_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__NoContextPartySubIDs, _p_FIX__NoContextPartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRelatedPartySubIDs, _p_FIX__NoRelatedPartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoSettlPartySubIDs, _p_FIX__NoSettlPartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoDerivativeInstrumentPartySubIDs, _p_FIX__NoDerivativeInstrumentPartySubIDsTo_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__NoNested2PartySubIDs, _p_FIX__NoNested2PartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRelatedContextPartySubIDs, _p_FIX__NoRelatedContextPartySubIDsTo_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__NoUndlyInstrumentParties, _p_FIX__NoUndlyInstrumentPartiesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoDerivativeInstrumentParties, _p_FIX__NoDerivativeInstrumentPartiesTo_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__NoNested4PartyIDs, _p_FIX__NoNested4PartyIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoContextPartyIDs, _p_FIX__NoContextPartyIDsTo_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__NoRelatedPartyIDs, _p_FIX__NoRelatedPartyIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoSettlPartyIDs, _p_FIX__NoSettlPartyIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoTargetPartyIDs, _p_FIX__NoTargetPartyIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRootPartyIDs, _p_FIX__NoRootPartyIDsTo_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__NoRelatedContextPartyIDs, _p_FIX__NoRelatedContextPartyIDsTo_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__NoPartyList, _p_FIX__NoPartyListTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNoPartyList, _p_FIX__TotNoPartyListTo_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__TotNumReports, _p_FIX__TotNumReportsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNumAssignmentReports, _p_FIX__TotNumAssignmentReportsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotalNumPosReports, _p_FIX__TotalNumPosReportsTo_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__NoRequestedPartyRoles, _p_FIX__NoRequestedPartyRolesTo_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__RepoCollateralSecurityType, _p_FIX__RepoCollateralSecurityTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegRepoCollateralSecurityType, _p_FIX__LegRepoCollateralSecurityTypeTo_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__UnderlyingRepoCollateralSecurityType, _p_FIX__UnderlyingRepoCollateralSecurityTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoPartyListResponseTypes, _p_FIX__NoPartyListResponseTypesTo_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__PartyListResponseType, _p_FIX__PartyListResponseTypeTo_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__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__EventType, _p_FIX__EventTypeTo_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__TotalNumSecurities, _p_FIX__TotalNumSecuritiesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LiquidityNumSecurities, _p_FIX__LiquidityNumSecuritiesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__OrderDelayUnit, _p_FIX__OrderDelayUnitTo_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__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__RelatedPartySubIDType, _p_FIX__RelatedPartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PartyAltSubIDType, _p_FIX__PartyAltSubIDTypeTo_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__RelatedPartyAltSubIDType, _p_FIX__RelatedPartyAltSubIDTypeTo_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__NoRiskLimits, _p_FIX__NoRiskLimitsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRelationshipRiskLimits, _p_FIX__NoRelationshipRiskLimitsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoDlvyInst, _p_FIX__NoDlvyInstTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeInstrumentPartySubIDType, _p_FIX__DerivativeInstrumentPartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RootPartySubIDType, _p_FIX__RootPartySubIDTypeTo_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__ContextPartySubIDType, _p_FIX__ContextPartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RelatedContextPartySubIDType, _p_FIX__RelatedContextPartySubIDTypeTo_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__PartyRelationship, _p_FIX__PartyRelationshipTo_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__NoRelatedPartyAltIDs, _p_FIX__NoRelatedPartyAltIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoPartyAltIDs, _p_FIX__NoPartyAltIDsTo_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__PartyDetailsRequestResult, _p_FIX__PartyDetailsRequestResultTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradeRequestResult, _p_FIX__TradeRequestResultTo_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__CollInquiryResult, _p_FIX__CollInquiryResultTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PosReqResult, _p_FIX__PosReqResultTo_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__EncodedSymbolLen, _p_FIX__EncodedSymbolLenTo_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__NoContextPartyIDs[] = {  {&_swigt__p_FIX__NoContextPartyIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoContextPartySubIDs[] = {  {&_swigt__p_FIX__NoContextPartySubIDs, 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__NoPartyAltIDs[] = {  {&_swigt__p_FIX__NoPartyAltIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoPartyAltSubIDs[] = {  {&_swigt__p_FIX__NoPartyAltSubIDs, 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__NoPartyList[] = {  {&_swigt__p_FIX__NoPartyList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoPartyListResponseTypes[] = {  {&_swigt__p_FIX__NoPartyListResponseTypes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoPartyRelationships[] = {  {&_swigt__p_FIX__NoPartyRelationships, 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__NoRelatedContextPartyIDs[] = {  {&_swigt__p_FIX__NoRelatedContextPartyIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRelatedContextPartySubIDs[] = {  {&_swigt__p_FIX__NoRelatedContextPartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRelatedPartyAltIDs[] = {  {&_swigt__p_FIX__NoRelatedPartyAltIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRelatedPartyAltSubIDs[] = {  {&_swigt__p_FIX__NoRelatedPartyAltSubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRelatedPartyIDs[] = {  {&_swigt__p_FIX__NoRelatedPartyIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRelatedPartySubIDs[] = {  {&_swigt__p_FIX__NoRelatedPartySubIDs, 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__NoRelationshipRiskInstruments[] = {  {&_swigt__p_FIX__NoRelationshipRiskInstruments, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRelationshipRiskLimits[] = {  {&_swigt__p_FIX__NoRelationshipRiskLimits, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRelationshipRiskSecurityAltID[] = {  {&_swigt__p_FIX__NoRelationshipRiskSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRelationshipRiskWarningLevels[] = {  {&_swigt__p_FIX__NoRelationshipRiskWarningLevels, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRequestedPartyRoles[] = {  {&_swigt__p_FIX__NoRequestedPartyRoles, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRiskInstruments[] = {  {&_swigt__p_FIX__NoRiskInstruments, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRiskLimits[] = {  {&_swigt__p_FIX__NoRiskLimits, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRiskSecurityAltID[] = {  {&_swigt__p_FIX__NoRiskSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRiskWarningLevels[] = {  {&_swigt__p_FIX__NoRiskWarningLevels, 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__PartyAltID[] = {  {&_swigt__p_FIX__PartyAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PartyAltIDSource[] = {  {&_swigt__p_FIX__PartyAltIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PartyAltSubID[] = {  {&_swigt__p_FIX__PartyAltSubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PartyAltSubIDType[] = {  {&_swigt__p_FIX__PartyAltSubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PartyDetailsListReportID[] = {  {&_swigt__p_FIX__PartyDetailsListReportID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PartyDetailsListRequestID[] = {  {&_swigt__p_FIX__PartyDetailsListRequestID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PartyDetailsRequestResult[] = {  {&_swigt__p_FIX__PartyDetailsRequestResult, 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__PartyListResponseType[] = {  {&_swigt__p_FIX__PartyListResponseType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PartyRelationship[] = {  {&_swigt__p_FIX__PartyRelationship, 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__RelatedContextPartyID[] = {  {&_swigt__p_FIX__RelatedContextPartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelatedContextPartyIDSource[] = {  {&_swigt__p_FIX__RelatedContextPartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelatedContextPartyRole[] = {  {&_swigt__p_FIX__RelatedContextPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelatedContextPartySubID[] = {  {&_swigt__p_FIX__RelatedContextPartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelatedContextPartySubIDType[] = {  {&_swigt__p_FIX__RelatedContextPartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelatedPartyAltID[] = {  {&_swigt__p_FIX__RelatedPartyAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelatedPartyAltIDSource[] = {  {&_swigt__p_FIX__RelatedPartyAltIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelatedPartyAltSubID[] = {  {&_swigt__p_FIX__RelatedPartyAltSubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelatedPartyAltSubIDType[] = {  {&_swigt__p_FIX__RelatedPartyAltSubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelatedPartyID[] = {  {&_swigt__p_FIX__RelatedPartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelatedPartyIDSource[] = {  {&_swigt__p_FIX__RelatedPartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelatedPartyRole[] = {  {&_swigt__p_FIX__RelatedPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelatedPartySubID[] = {  {&_swigt__p_FIX__RelatedPartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelatedPartySubIDType[] = {  {&_swigt__p_FIX__RelatedPartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskCFICode[] = {  {&_swigt__p_FIX__RelationshipRiskCFICode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskCouponRate[] = {  {&_swigt__p_FIX__RelationshipRiskCouponRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskEncodedSecurityDesc[] = {  {&_swigt__p_FIX__RelationshipRiskEncodedSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskEncodedSecurityDescLen[] = {  {&_swigt__p_FIX__RelationshipRiskEncodedSecurityDescLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskFlexibleIndicator[] = {  {&_swigt__p_FIX__RelationshipRiskFlexibleIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskInstrumentMultiplier[] = {  {&_swigt__p_FIX__RelationshipRiskInstrumentMultiplier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskInstrumentOperator[] = {  {&_swigt__p_FIX__RelationshipRiskInstrumentOperator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskInstrumentSettlType[] = {  {&_swigt__p_FIX__RelationshipRiskInstrumentSettlType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskLimitAmount[] = {  {&_swigt__p_FIX__RelationshipRiskLimitAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskLimitCurrency[] = {  {&_swigt__p_FIX__RelationshipRiskLimitCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskLimitPlatform[] = {  {&_swigt__p_FIX__RelationshipRiskLimitPlatform, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskLimitType[] = {  {&_swigt__p_FIX__RelationshipRiskLimitType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskMaturityMonthYear[] = {  {&_swigt__p_FIX__RelationshipRiskMaturityMonthYear, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskMaturityTime[] = {  {&_swigt__p_FIX__RelationshipRiskMaturityTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskProduct[] = {  {&_swigt__p_FIX__RelationshipRiskProduct, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskProductComplex[] = {  {&_swigt__p_FIX__RelationshipRiskProductComplex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskPutOrCall[] = {  {&_swigt__p_FIX__RelationshipRiskPutOrCall, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskRestructuringType[] = {  {&_swigt__p_FIX__RelationshipRiskRestructuringType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskSecurityAltID[] = {  {&_swigt__p_FIX__RelationshipRiskSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskSecurityAltIDSource[] = {  {&_swigt__p_FIX__RelationshipRiskSecurityAltIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskSecurityDesc[] = {  {&_swigt__p_FIX__RelationshipRiskSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskSecurityExchange[] = {  {&_swigt__p_FIX__RelationshipRiskSecurityExchange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskSecurityGroup[] = {  {&_swigt__p_FIX__RelationshipRiskSecurityGroup, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskSecurityID[] = {  {&_swigt__p_FIX__RelationshipRiskSecurityID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskSecurityIDSource[] = {  {&_swigt__p_FIX__RelationshipRiskSecurityIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskSecuritySubType[] = {  {&_swigt__p_FIX__RelationshipRiskSecuritySubType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskSecurityType[] = {  {&_swigt__p_FIX__RelationshipRiskSecurityType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskSeniority[] = {  {&_swigt__p_FIX__RelationshipRiskSeniority, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskSymbol[] = {  {&_swigt__p_FIX__RelationshipRiskSymbol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskSymbolSfx[] = {  {&_swigt__p_FIX__RelationshipRiskSymbolSfx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskWarningLevelName[] = {  {&_swigt__p_FIX__RelationshipRiskWarningLevelName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskWarningLevelPercent[] = {  {&_swigt__p_FIX__RelationshipRiskWarningLevelPercent, 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__RequestedPartyRole[] = {  {&_swigt__p_FIX__RequestedPartyRole, 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__RiskCFICode[] = {  {&_swigt__p_FIX__RiskCFICode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskCouponRate[] = {  {&_swigt__p_FIX__RiskCouponRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskEncodedSecurityDesc[] = {  {&_swigt__p_FIX__RiskEncodedSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskEncodedSecurityDescLen[] = {  {&_swigt__p_FIX__RiskEncodedSecurityDescLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskFlexibleIndicator[] = {  {&_swigt__p_FIX__RiskFlexibleIndicator, 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__RiskInstrumentMultiplier[] = {  {&_swigt__p_FIX__RiskInstrumentMultiplier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskInstrumentOperator[] = {  {&_swigt__p_FIX__RiskInstrumentOperator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskInstrumentSettlType[] = {  {&_swigt__p_FIX__RiskInstrumentSettlType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskLimitAmount[] = {  {&_swigt__p_FIX__RiskLimitAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskLimitCurrency[] = {  {&_swigt__p_FIX__RiskLimitCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskLimitPlatform[] = {  {&_swigt__p_FIX__RiskLimitPlatform, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskLimitType[] = {  {&_swigt__p_FIX__RiskLimitType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskMaturityMonthYear[] = {  {&_swigt__p_FIX__RiskMaturityMonthYear, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskMaturityTime[] = {  {&_swigt__p_FIX__RiskMaturityTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskProduct[] = {  {&_swigt__p_FIX__RiskProduct, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskProductComplex[] = {  {&_swigt__p_FIX__RiskProductComplex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskPutOrCall[] = {  {&_swigt__p_FIX__RiskPutOrCall, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskRestructuringType[] = {  {&_swigt__p_FIX__RiskRestructuringType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskSecurityAltID[] = {  {&_swigt__p_FIX__RiskSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskSecurityAltIDSource[] = {  {&_swigt__p_FIX__RiskSecurityAltIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskSecurityDesc[] = {  {&_swigt__p_FIX__RiskSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskSecurityExchange[] = {  {&_swigt__p_FIX__RiskSecurityExchange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskSecurityGroup[] = {  {&_swigt__p_FIX__RiskSecurityGroup, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskSecurityID[] = {  {&_swigt__p_FIX__RiskSecurityID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskSecurityIDSource[] = {  {&_swigt__p_FIX__RiskSecurityIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskSecuritySubType[] = {  {&_swigt__p_FIX__RiskSecuritySubType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskSecurityType[] = {  {&_swigt__p_FIX__RiskSecurityType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskSeniority[] = {  {&_swigt__p_FIX__RiskSeniority, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskSymbol[] = {  {&_swigt__p_FIX__RiskSymbol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskSymbolSfx[] = {  {&_swigt__p_FIX__RiskSymbolSfx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskWarningLevelName[] = {  {&_swigt__p_FIX__RiskWarningLevelName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskWarningLevelPercent[] = {  {&_swigt__p_FIX__RiskWarningLevelPercent, 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__SecDefStatus[] = {  {&_swigt__p_FIX__SecDefStatus, 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__PartyDetailsListRequestID, _p_FIX__PartyDetailsListRequestIDTo_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__LegInstrRegistry, _p_FIX__LegInstrRegistryTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__InstrRegistry, _p_FIX__InstrRegistryTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeInstrRegistry, _p_FIX__DerivativeInstrRegistryTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrRegistry, _p_FIX__UnderlyingInstrRegistryTo_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__RelationshipRiskSecurityDesc, _p_FIX__RelationshipRiskSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedSecurityDesc, _p_FIX__EncodedSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityDesc, _p_FIX__UnderlyingSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RiskEncodedSecurityDesc, _p_FIX__RiskEncodedSecurityDescTo_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__DerivativeEncodedSecurityDesc, _p_FIX__DerivativeEncodedSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSecurityDesc, _p_FIX__LegSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskEncodedSecurityDesc, _p_FIX__RelationshipRiskEncodedSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RiskSecurityDesc, _p_FIX__RiskSecurityDescTo_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__RiskLimitPlatform, _p_FIX__RiskLimitPlatformTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskLimitPlatform, _p_FIX__RelationshipRiskLimitPlatformTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelatedContextPartyID, _p_FIX__RelatedContextPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartyID, _p_FIX__UnderlyingInstrumentPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NestedPartyID, _p_FIX__NestedPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelatedPartyID, _p_FIX__RelatedPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Nested3PartyID, _p_FIX__Nested3PartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlPartyID, _p_FIX__SettlPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ContextPartyID, _p_FIX__ContextPartyIDTo_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__TargetPartyID, _p_FIX__TargetPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartyID, _p_FIX__UndlyInstrumentPartyIDTo_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__ExecID, _p_FIX__ExecIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecondaryExecID, _p_FIX__SecondaryExecIDTo_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__RelatedPartyAltID, _p_FIX__RelatedPartyAltIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSecurityAltID, _p_FIX__RelationshipRiskSecurityAltIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NoLegSecurityAltID, _p_FIX__NoLegSecurityAltIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityAltID, _p_FIX__SecurityAltIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PartyAltID, _p_FIX__PartyAltIDTo_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__RiskSecurityAltID, _p_FIX__RiskSecurityAltIDTo_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__PartyAltSubID, _p_FIX__PartyAltSubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelatedPartyAltSubID, _p_FIX__RelatedPartyAltSubIDTo_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__AllocSettlCurrency, _p_FIX__AllocSettlCurrencyTo_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__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__RiskLimitCurrency, _p_FIX__RiskLimitCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskLimitCurrency, _p_FIX__RelationshipRiskLimitCurrencyTo_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__FinancialStatus, _p_FIX__FinancialStatusTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlementStatus, _p_FIX__UnderlyingSettlementStatusTo_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__RefOrderID, _p_FIX__RefOrderIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecondaryOrderID, _p_FIX__SecondaryOrderIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AffectedSecondaryOrderID, _p_FIX__AffectedSecondaryOrderIDTo_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__AsgnReqID, _p_FIX__AsgnReqIDTo_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__LegFutSettDate, _p_FIX__LegFutSettDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__FutSettDate, _p_FIX__FutSettDateTo_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__TradeID, _p_FIX__TradeIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecondaryFirmTradeID, _p_FIX__SecondaryFirmTradeIDTo_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__BenchmarkSecurityID, _p_FIX__BenchmarkSecurityIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityID, _p_FIX__DerivativeSecurityIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PegSecurityID, _p_FIX__PegSecurityIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RiskSecurityID, _p_FIX__RiskSecurityIDTo_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__RelationshipRiskSecurityID, _p_FIX__RelationshipRiskSecurityIDTo_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__EncodedSymbol, _p_FIX__EncodedSymbolTo_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__RiskSymbol, _p_FIX__RiskSymbolTo_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__RelationshipRiskSymbol, _p_FIX__RelationshipRiskSymbolTo_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__NewPassword, _p_FIX__NewPasswordTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncryptedNewPassword, _p_FIX__EncryptedNewPasswordTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Password, _p_FIX__PasswordTo_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__ApplReqID, _p_FIX__ApplReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RefApplReqID, _p_FIX__RefApplReqIDTo_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__RiskSecurityGroup, _p_FIX__RiskSecurityGroupTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityGroup, _p_FIX__DerivativeSecurityGroupTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSecurityGroup, _p_FIX__RelationshipRiskSecurityGroupTo_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__RiskSeniority, _p_FIX__RiskSeniorityTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSeniority, _p_FIX__RelationshipRiskSeniorityTo_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__RelationshipRiskCFICode, _p_FIX__RelationshipRiskCFICodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RiskCFICode, _p_FIX__RiskCFICodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegCFICode, _p_FIX__LegCFICodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeCFICode, _p_FIX__DerivativeCFICodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AsgnRptID, _p_FIX__AsgnRptIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingCFICode, _p_FIX__UnderlyingCFICodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StreamAsgnRptID, _p_FIX__StreamAsgnRptIDTo_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__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__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__SecondaryTradeReportID, _p_FIX__SecondaryTradeReportIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PartyDetailsListReportID, _p_FIX__PartyDetailsListReportIDTo_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__UnderlyingLegSecurityType, _p_FIX__UnderlyingLegSecurityTypeTo_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__RiskSecurityType, _p_FIX__RiskSecurityTypeTo_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__RelationshipRiskSecurityType, _p_FIX__RelationshipRiskSecurityTypeTo_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__DerivativeIssueDate, _p_FIX__DerivativeIssueDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingIssueDate, _p_FIX__UnderlyingIssueDateTo_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__RiskSecurityAltIDSource, _p_FIX__RiskSecurityAltIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSecurityIDSource, _p_FIX__RelationshipRiskSecurityIDSourceTo_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__IDSource, _p_FIX__IDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityAltIDSource, _p_FIX__DerivativeSecurityAltIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RiskSecurityIDSource, _p_FIX__RiskSecurityIDSourceTo_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__DerivativeInstrumentPartyIDSource, _p_FIX__DerivativeInstrumentPartyIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityIDSource, _p_FIX__SecurityIDSourceTo_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__RelationshipRiskSecurityAltIDSource, _p_FIX__RelationshipRiskSecurityAltIDSourceTo_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__SideComplianceID, _p_FIX__SideComplianceIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ComplianceID, _p_FIX__ComplianceIDTo_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__AllocReportRefID, _p_FIX__AllocReportRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeReportRefID, _p_FIX__TradeReportRefIDTo_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__ContextPartySubID, _p_FIX__ContextPartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__InstrumentPartySubID, _p_FIX__InstrumentPartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelatedContextPartySubID, _p_FIX__RelatedContextPartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelatedPartySubID, _p_FIX__RelatedPartySubIDTo_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__RiskSymbolSfx, _p_FIX__RiskSymbolSfxTo_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__RelationshipRiskSymbolSfx, _p_FIX__RelationshipRiskSymbolSfxTo_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__SecuritySubType, _p_FIX__SecuritySubTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSecuritySubType, _p_FIX__RelationshipRiskSecuritySubTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecuritySubType, _p_FIX__DerivativeSecuritySubTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSecuritySubType, _p_FIX__LegSecuritySubTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RiskSecuritySubType, _p_FIX__RiskSecuritySubTypeTo_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__RiskWarningLevelName, _p_FIX__RiskWarningLevelNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskWarningLevelName, _p_FIX__RelationshipRiskWarningLevelNameTo_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__MaturityDate, _p_FIX__MaturityDateTo_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__DerivativeMaturityDate, _p_FIX__DerivativeMaturityDateTo_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__QuoteStatusReqID, _p_FIX__QuoteStatusReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OrdStatusReqID, _p_FIX__OrdStatusReqIDTo_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__LegMaturityTime, _p_FIX__LegMaturityTimeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegMaturityTime, _p_FIX__UnderlyingLegMaturityTimeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskMaturityTime, _p_FIX__RelationshipRiskMaturityTimeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeMaturityTime, _p_FIX__DerivativeMaturityTimeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RiskMaturityTime, _p_FIX__RiskMaturityTimeTo_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__UnderlyingSettlementDate, _p_FIX__UnderlyingSettlementDateTo_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__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__RelationshipRiskInstrumentSettlType, _p_FIX__RelationshipRiskInstrumentSettlTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RegistDetls, _p_FIX__RegistDetlsTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RiskInstrumentSettlType, _p_FIX__RiskInstrumentSettlTypeTo_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__NestedInstrAttribValue, _p_FIX__NestedInstrAttribValueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeInstrAttribValue, _p_FIX__DerivativeInstrAttribValueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__InstrAttribValue, _p_FIX__InstrAttribValueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityExchange, _p_FIX__UnderlyingSecurityExchangeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RiskSecurityExchange, _p_FIX__RiskSecurityExchangeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSecurityExchange, _p_FIX__RelationshipRiskSecurityExchangeTo_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__RiskRestructuringType, _p_FIX__RiskRestructuringTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RestructuringType, _p_FIX__RestructuringTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskRestructuringType, _p_FIX__RelationshipRiskRestructuringTypeTo_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__RiskProductComplex, _p_FIX__RiskProductComplexTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskProductComplex, _p_FIX__RelationshipRiskProductComplexTo_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__RelationshipRiskMaturityMonthYear, _p_FIX__RelationshipRiskMaturityMonthYearTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RiskMaturityMonthYear, _p_FIX__RiskMaturityMonthYearTo_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__TotNoPartyList[] = {  {&_swigt__p_FIX__TotNoPartyList, 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__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__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__setTFIX__SessionID_t[] = {  {&_swigt__p_std__setTFIX__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__vectorTstd__string_t[] = {  {&_swigt__p_std__vectorTstd__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_DateTime,
  _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__AsgnReqID,
  _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__ContextPartyID,
  _swigc__p_FIX__ContextPartyIDSource,
  _swigc__p_FIX__ContextPartyRole,
  _swigc__p_FIX__ContextPartySubID,
  _swigc__p_FIX__ContextPartySubIDType,
  _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__DerivativeSecurityListRequestType,
  _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__EncodedSymbol,
  _swigc__p_FIX__EncodedSymbolLen,
  _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__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__NoContextPartyIDs,
  _swigc__p_FIX__NoContextPartySubIDs,
  _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__NoPartyAltIDs,
  _swigc__p_FIX__NoPartyAltSubIDs,
  _swigc__p_FIX__NoPartyIDs,
  _swigc__p_FIX__NoPartyList,
  _swigc__p_FIX__NoPartyListResponseTypes,
  _swigc__p_FIX__NoPartyRelationships,
  _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__NoRelatedContextPartyIDs,
  _swigc__p_FIX__NoRelatedContextPartySubIDs,
  _swigc__p_FIX__NoRelatedPartyAltIDs,
  _swigc__p_FIX__NoRelatedPartyAltSubIDs,
  _swigc__p_FIX__NoRelatedPartyIDs,
  _swigc__p_FIX__NoRelatedPartySubIDs,
  _swigc__p_FIX__NoRelatedSym,
  _swigc__p_FIX__NoRelationshipRiskInstruments,
  _swigc__p_FIX__NoRelationshipRiskLimits,
  _swigc__p_FIX__NoRelationshipRiskSecurityAltID,
  _swigc__p_FIX__NoRelationshipRiskWarningLevels,
  _swigc__p_FIX__NoRequestedPartyRoles,
  _swigc__p_FIX__NoRiskInstruments,
  _swigc__p_FIX__NoRiskLimits,
  _swigc__p_FIX__NoRiskSecurityAltID,
  _swigc__p_FIX__NoRiskWarningLevels,
  _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__PartyAltID,
  _swigc__p_FIX__PartyAltIDSource,
  _swigc__p_FIX__PartyAltSubID,
  _swigc__p_FIX__PartyAltSubIDType,
  _swigc__p_FIX__PartyDetailsListReportID,
  _swigc__p_FIX__PartyDetailsListRequestID,
  _swigc__p_FIX__PartyDetailsRequestResult,
  _swigc__p_FIX__PartyID,
  _swigc__p_FIX__PartyIDSource,
  _swigc__p_FIX__PartyListResponseType,
  _swigc__p_FIX__PartyRelationship,
  _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__RelatedContextPartyID,
  _swigc__p_FIX__RelatedContextPartyIDSource,
  _swigc__p_FIX__RelatedContextPartyRole,
  _swigc__p_FIX__RelatedContextPartySubID,
  _swigc__p_FIX__RelatedContextPartySubIDType,
  _swigc__p_FIX__RelatedPartyAltID,
  _swigc__p_FIX__RelatedPartyAltIDSource,
  _swigc__p_FIX__RelatedPartyAltSubID,
  _swigc__p_FIX__RelatedPartyAltSubIDType,
  _swigc__p_FIX__RelatedPartyID,
  _swigc__p_FIX__RelatedPartyIDSource,
  _swigc__p_FIX__RelatedPartyRole,
  _swigc__p_FIX__RelatedPartySubID,
  _swigc__p_FIX__RelatedPartySubIDType,
  _swigc__p_FIX__RelationshipRiskCFICode,
  _swigc__p_FIX__RelationshipRiskCouponRate,
  _swigc__p_FIX__RelationshipRiskEncodedSecurityDesc,
  _swigc__p_FIX__RelationshipRiskEncodedSecurityDescLen,
  _swigc__p_FIX__RelationshipRiskFlexibleIndicator,
  _swigc__p_FIX__RelationshipRiskInstrumentMultiplier,
  _swigc__p_FIX__RelationshipRiskInstrumentOperator,
  _swigc__p_FIX__RelationshipRiskInstrumentSettlType,
  _swigc__p_FIX__RelationshipRiskLimitAmount,
  _swigc__p_FIX__RelationshipRiskLimitCurrency,
  _swigc__p_FIX__RelationshipRiskLimitPlatform,
  _swigc__p_FIX__RelationshipRiskLimitType,
  _swigc__p_FIX__RelationshipRiskMaturityMonthYear,
  _swigc__p_FIX__RelationshipRiskMaturityTime,
  _swigc__p_FIX__RelationshipRiskProduct,
  _swigc__p_FIX__RelationshipRiskProductComplex,
  _swigc__p_FIX__RelationshipRiskPutOrCall,
  _swigc__p_FIX__RelationshipRiskRestructuringType,
  _swigc__p_FIX__RelationshipRiskSecurityAltID,
  _swigc__p_FIX__RelationshipRiskSecurityAltIDSource,
  _swigc__p_FIX__RelationshipRiskSecurityDesc,
  _swigc__p_FIX__RelationshipRiskSecurityExchange,
  _swigc__p_FIX__RelationshipRiskSecurityGroup,
  _swigc__p_FIX__RelationshipRiskSecurityID,
  _swigc__p_FIX__RelationshipRiskSecurityIDSource,
  _swigc__p_FIX__RelationshipRiskSecuritySubType,
  _swigc__p_FIX__RelationshipRiskSecurityType,
  _swigc__p_FIX__RelationshipRiskSeniority,
  _swigc__p_FIX__RelationshipRiskSymbol,
  _swigc__p_FIX__RelationshipRiskSymbolSfx,
  _swigc__p_FIX__RelationshipRiskWarningLevelName,
  _swigc__p_FIX__RelationshipRiskWarningLevelPercent,
  _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__RequestedPartyRole,
  _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__RiskCFICode,
  _swigc__p_FIX__RiskCouponRate,
  _swigc__p_FIX__RiskEncodedSecurityDesc,
  _swigc__p_FIX__RiskEncodedSecurityDescLen,
  _swigc__p_FIX__RiskFlexibleIndicator,
  _swigc__p_FIX__RiskFreeRate,
  _swigc__p_FIX__RiskInstrumentMultiplier,
  _swigc__p_FIX__RiskInstrumentOperator,
  _swigc__p_FIX__RiskInstrumentSettlType,
  _swigc__p_FIX__RiskLimitAmount,
  _swigc__p_FIX__RiskLimitCurrency,
  _swigc__p_FIX__RiskLimitPlatform,
  _swigc__p_FIX__RiskLimitType,
  _swigc__p_FIX__RiskMaturityMonthYear,
  _swigc__p_FIX__RiskMaturityTime,
  _swigc__p_FIX__RiskProduct,
  _swigc__p_FIX__RiskProductComplex,
  _swigc__p_FIX__RiskPutOrCall,
  _swigc__p_FIX__RiskRestructuringType,
  _swigc__p_FIX__RiskSecurityAltID,
  _swigc__p_FIX__RiskSecurityAltIDSource,
  _swigc__p_FIX__RiskSecurityDesc,
  _swigc__p_FIX__RiskSecurityExchange,
  _swigc__p_FIX__RiskSecurityGroup,
  _swigc__p_FIX__RiskSecurityID,
  _swigc__p_FIX__RiskSecurityIDSource,
  _swigc__p_FIX__RiskSecuritySubType,
  _swigc__p_FIX__RiskSecurityType,
  _swigc__p_FIX__RiskSeniority,
  _swigc__p_FIX__RiskSymbol,
  _swigc__p_FIX__RiskSymbolSfx,
  _swigc__p_FIX__RiskWarningLevelName,
  _swigc__p_FIX__RiskWarningLevelPercent,
  _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__SecDefStatus,
  _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__TotNoPartyList,
  _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__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__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__setTFIX__SessionID_t,
  _swigc__p_std__string,
  _swigc__p_std__string__size_type,
  _swigc__p_std__vectorTstd__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;
  
  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;
  }
  
  /* 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;
  }
  
  /* 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)) {
    return PyString_FromString("<Swig global variables>");
  }
  
  SWIGINTERN PyObject *
  swig_varlink_str(swig_varlinkobject *v) {
    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(")"));
    return str;
  }
  
  SWIGINTERN int
  swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
    PyObject *str = swig_varlink_str(v);
    fprintf(fp,"Swig global variables ");
    fprintf(fp,"%s\n", PyString_AsString(str));
    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_HEAD_INIT(NULL)
        0,                                  /* Number of items in variable part (ob_size) */
        (char *)"swigvarlink",              /* Type name (tp_name) */
        sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
        0,                                  /* Itemsize (tp_itemsize) */
        (destructor) swig_varlink_dealloc,   /* Deallocator (tp_dealloc) */ 
        (printfunc) swig_varlink_print,     /* Print (tp_print) */
        (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
        (setattrfunc) swig_varlink_setattr, /* Set attr (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
#ifdef COUNT_ALLOCS
        0,0,0,0                             /* tp_alloc -> tp_next */
#endif
      };
      varlink_type = tmp;
      varlink_type.ob_type = &PyType_Type;
      type_init = 1;
    }
    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_NewPointerObj(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) {
          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;
            void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
            if (ptr) {
              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 void SWIG_init(void) {
  PyObject *m, *d;
  
  /* Fix SwigMethods to carry the callback ptrs when needed */
  SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
  
  m = Py_InitModule((char *) SWIG_name, SwigMethods);
  d = PyModule_GetDict(m);
  
  SWIG_InitializeModule(0);
  SWIG_InstallConstants(d,swig_const_table);
  
  
  
#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
  
  PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
  SWIG_addvarlink(SWIG_globals(),(char*)"headerOrder",headerOrder_get, headerOrder_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BeginString_FIXT11",BeginString_FIXT11_get, BeginString_FIXT11_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BeginString_FIX50",BeginString_FIX50_get, BeginString_FIX50_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BeginString_FIX44",BeginString_FIX44_get, BeginString_FIX44_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BeginString_FIX43",BeginString_FIX43_get, BeginString_FIX43_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BeginString_FIX42",BeginString_FIX42_get, BeginString_FIX42_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BeginString_FIX41",BeginString_FIX41_get, BeginString_FIX41_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BeginString_FIX40",BeginString_FIX40_get, BeginString_FIX40_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_INVALID_TAG_NUMBER_TEXT",SessionRejectReason_INVALID_TAG_NUMBER_TEXT_get, SessionRejectReason_INVALID_TAG_NUMBER_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_REQUIRED_TAG_MISSING_TEXT",SessionRejectReason_REQUIRED_TAG_MISSING_TEXT_get, SessionRejectReason_REQUIRED_TAG_MISSING_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_TEXT",SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_TEXT_get, SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_UNDEFINED_TAG_TEXT",SessionRejectReason_UNDEFINED_TAG_TEXT_get, SessionRejectReason_UNDEFINED_TAG_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_TEXT",SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_TEXT_get, SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_VALUE_IS_INCORRECT_TEXT",SessionRejectReason_VALUE_IS_INCORRECT_TEXT_get, SessionRejectReason_VALUE_IS_INCORRECT_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_TEXT",SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_TEXT_get, SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_DECRYPTION_PROBLEM_TEXT",SessionRejectReason_DECRYPTION_PROBLEM_TEXT_get, SessionRejectReason_DECRYPTION_PROBLEM_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_SIGNATURE_PROBLEM_TEXT",SessionRejectReason_SIGNATURE_PROBLEM_TEXT_get, SessionRejectReason_SIGNATURE_PROBLEM_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_COMPID_PROBLEM_TEXT",SessionRejectReason_COMPID_PROBLEM_TEXT_get, SessionRejectReason_COMPID_PROBLEM_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_TEXT",SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_TEXT_get, SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_INVALID_MSGTYPE_TEXT",SessionRejectReason_INVALID_MSGTYPE_TEXT_get, SessionRejectReason_INVALID_MSGTYPE_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_TEXT",SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_TEXT_get, SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_TEXT",SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_TEXT_get, SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_TEXT",SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_TEXT_get, SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_OTHER_TEXT",BusinessRejectReason_OTHER_TEXT_get, BusinessRejectReason_OTHER_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_UNKNOWN_ID_TEXT",BusinessRejectReason_UNKNOWN_ID_TEXT_get, BusinessRejectReason_UNKNOWN_ID_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_UNKNOWN_SECURITY_TEXT",BusinessRejectReason_UNKNOWN_SECURITY_TEXT_get, BusinessRejectReason_UNKNOWN_SECURITY_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_TEXT",BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_TEXT_get, BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_APPLICATION_NOT_AVAILABLE_TEXT",BusinessRejectReason_APPLICATION_NOT_AVAILABLE_TEXT_get, BusinessRejectReason_APPLICATION_NOT_AVAILABLE_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_TEXT",BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_TEXT_get, BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_NOT_AUTHORIZED_TEXT",BusinessRejectReason_NOT_AUTHORIZED_TEXT_get, BusinessRejectReason_NOT_AUTHORIZED_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_TEXT",BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_TEXT_get, BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeliveryForm_BOOKENTRY",DeliveryForm_BOOKENTRY_get, DeliveryForm_BOOKENTRY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeliveryForm_BEARER",DeliveryForm_BEARER_get, DeliveryForm_BEARER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeliveryForm_BOOK_ENTRY",DeliveryForm_BOOK_ENTRY_get, DeliveryForm_BOOK_ENTRY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_GTRENEW",ExecRestatementReason_GTRENEW_get, ExecRestatementReason_GTRENEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_WAREHOUSE_RECAP",ExecRestatementReason_WAREHOUSE_RECAP_get, ExecRestatementReason_WAREHOUSE_RECAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_CANCELEDNOTBEST",ExecRestatementReason_CANCELEDNOTBEST_get, ExecRestatementReason_CANCELEDNOTBEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_CANCEL_ON_SYSTEM_FAILURE",ExecRestatementReason_CANCEL_ON_SYSTEM_FAILURE_get, ExecRestatementReason_CANCEL_ON_SYSTEM_FAILURE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_CXLTRADINGHALT",ExecRestatementReason_CXLTRADINGHALT_get, ExecRestatementReason_CXLTRADINGHALT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_PARTIAL_DECLINE_OF_ORDERQTY",ExecRestatementReason_PARTIAL_DECLINE_OF_ORDERQTY_get, ExecRestatementReason_PARTIAL_DECLINE_OF_ORDERQTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_GT_CORPORATE_ACTION",ExecRestatementReason_GT_CORPORATE_ACTION_get, ExecRestatementReason_GT_CORPORATE_ACTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_PEG_REFRESH",ExecRestatementReason_PEG_REFRESH_get, ExecRestatementReason_PEG_REFRESH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_VERBAL",ExecRestatementReason_VERBAL_get, ExecRestatementReason_VERBAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_CANCELED_NOT_BEST",ExecRestatementReason_CANCELED_NOT_BEST_get, ExecRestatementReason_CANCELED_NOT_BEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_CANCEL_ON_TRADING_HALT",ExecRestatementReason_CANCEL_ON_TRADING_HALT_get, ExecRestatementReason_CANCEL_ON_TRADING_HALT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_REPX",ExecRestatementReason_REPX_get, ExecRestatementReason_REPX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_MRKTOPTION",ExecRestatementReason_MRKTOPTION_get, ExecRestatementReason_MRKTOPTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_VERBAL_CHANGE",ExecRestatementReason_VERBAL_CHANGE_get, ExecRestatementReason_VERBAL_CHANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_PARTDEC",ExecRestatementReason_PARTDEC_get, ExecRestatementReason_PARTDEC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_CXLSYSTEMFAILURE",ExecRestatementReason_CXLSYSTEMFAILURE_get, ExecRestatementReason_CXLSYSTEMFAILURE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_GTCORPACT",ExecRestatementReason_GTCORPACT_get, ExecRestatementReason_GTCORPACT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_OTHER",ExecRestatementReason_OTHER_get, ExecRestatementReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_BROKER_OPTION",ExecRestatementReason_BROKER_OPTION_get, ExecRestatementReason_BROKER_OPTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_WAREHOUSERECAP",ExecRestatementReason_WAREHOUSERECAP_get, ExecRestatementReason_WAREHOUSERECAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_BRKROPT",ExecRestatementReason_BRKROPT_get, ExecRestatementReason_BRKROPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_REPRICING_OF_ORDER",ExecRestatementReason_REPRICING_OF_ORDER_get, ExecRestatementReason_REPRICING_OF_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_MARKET",ExecRestatementReason_MARKET_get, ExecRestatementReason_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_GT_RENEWAL",ExecRestatementReason_GT_RENEWAL_get, ExecRestatementReason_GT_RENEWAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocIntermedReqType_PENDING_RELEASE",AllocIntermedReqType_PENDING_RELEASE_get, AllocIntermedReqType_PENDING_RELEASE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocIntermedReqType_PENDING_REVERSAL",AllocIntermedReqType_PENDING_REVERSAL_get, AllocIntermedReqType_PENDING_REVERSAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocIntermedReqType_ACCOUNTLEVELREJECT",AllocIntermedReqType_ACCOUNTLEVELREJECT_get, AllocIntermedReqType_ACCOUNTLEVELREJECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocIntermedReqType_PENDINGACCEPT",AllocIntermedReqType_PENDINGACCEPT_get, AllocIntermedReqType_PENDINGACCEPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocIntermedReqType_BLOCK_LEVEL_REJECT",AllocIntermedReqType_BLOCK_LEVEL_REJECT_get, AllocIntermedReqType_BLOCK_LEVEL_REJECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocIntermedReqType_ACCOUNT_LEVEL_REJECT",AllocIntermedReqType_ACCOUNT_LEVEL_REJECT_get, AllocIntermedReqType_ACCOUNT_LEVEL_REJECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocIntermedReqType_BLOCKLEVELREJECT",AllocIntermedReqType_BLOCKLEVELREJECT_get, AllocIntermedReqType_BLOCKLEVELREJECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocIntermedReqType_PENDING_ACCEPT",AllocIntermedReqType_PENDING_ACCEPT_get, AllocIntermedReqType_PENDING_ACCEPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocIntermedReqType_PENDINGREVERSAL",AllocIntermedReqType_PENDINGREVERSAL_get, AllocIntermedReqType_PENDINGREVERSAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocIntermedReqType_PENDINGRELEASE",AllocIntermedReqType_PENDINGRELEASE_get, AllocIntermedReqType_PENDINGRELEASE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocIntermedReqType_ACCEPT",AllocIntermedReqType_ACCEPT_get, AllocIntermedReqType_ACCEPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityListTypeSource_GICS",SecurityListTypeSource_GICS_get, SecurityListTypeSource_GICS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityListTypeSource_NAICS",SecurityListTypeSource_NAICS_get, SecurityListTypeSource_NAICS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityListTypeSource_ICB",SecurityListTypeSource_ICB_get, SecurityListTypeSource_ICB_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryQualifier_PARTIALLY_ASSIGNED",CollInquiryQualifier_PARTIALLY_ASSIGNED_get, CollInquiryQualifier_PARTIALLY_ASSIGNED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryQualifier_OUTSTANDING_TRADES",CollInquiryQualifier_OUTSTANDING_TRADES_get, CollInquiryQualifier_OUTSTANDING_TRADES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryQualifier_SUBSTITUTIONELIGIBLE",CollInquiryQualifier_SUBSTITUTIONELIGIBLE_get, CollInquiryQualifier_SUBSTITUTIONELIGIBLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryQualifier_TRADE_DATE",CollInquiryQualifier_TRADE_DATE_get, CollInquiryQualifier_TRADE_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryQualifier_FULLYASSIGNED",CollInquiryQualifier_FULLYASSIGNED_get, CollInquiryQualifier_FULLYASSIGNED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryQualifier_SUBSTITUTION_ELIGIBLE",CollInquiryQualifier_SUBSTITUTION_ELIGIBLE_get, CollInquiryQualifier_SUBSTITUTION_ELIGIBLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryQualifier_FULLY_ASSIGNED",CollInquiryQualifier_FULLY_ASSIGNED_get, CollInquiryQualifier_FULLY_ASSIGNED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryQualifier_NOTASSIGNED",CollInquiryQualifier_NOTASSIGNED_get, CollInquiryQualifier_NOTASSIGNED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryQualifier_GCINSTRUMENT",CollInquiryQualifier_GCINSTRUMENT_get, CollInquiryQualifier_GCINSTRUMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryQualifier_NOT_ASSIGNED",CollInquiryQualifier_NOT_ASSIGNED_get, CollInquiryQualifier_NOT_ASSIGNED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryQualifier_COLLATERAL_INSTRUMENT",CollInquiryQualifier_COLLATERAL_INSTRUMENT_get, CollInquiryQualifier_COLLATERAL_INSTRUMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryQualifier_OUTSTANDINGTRADES",CollInquiryQualifier_OUTSTANDINGTRADES_get, CollInquiryQualifier_OUTSTANDINGTRADES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryQualifier_TRADEDATE",CollInquiryQualifier_TRADEDATE_get, CollInquiryQualifier_TRADEDATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryQualifier_GC_INSTRUMENT",CollInquiryQualifier_GC_INSTRUMENT_get, CollInquiryQualifier_GC_INSTRUMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryQualifier_PARTIALLYASSIGNED",CollInquiryQualifier_PARTIALLYASSIGNED_get, CollInquiryQualifier_PARTIALLYASSIGNED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryQualifier_COLLATERALINSTRUMENT",CollInquiryQualifier_COLLATERALINSTRUMENT_get, CollInquiryQualifier_COLLATERALINSTRUMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContingencyType_ONE_UPDATES_THE_OTHER_4",ContingencyType_ONE_UPDATES_THE_OTHER_4_get, ContingencyType_ONE_UPDATES_THE_OTHER_4_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContingencyType_ONE_TRIGGERS_THE_OTHER",ContingencyType_ONE_TRIGGERS_THE_OTHER_get, ContingencyType_ONE_TRIGGERS_THE_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContingencyType_ONE_CANCELS_THE_OTHER",ContingencyType_ONE_CANCELS_THE_OTHER_get, ContingencyType_ONE_CANCELS_THE_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContingencyType_ONE_UPDATES_THE_OTHER_3",ContingencyType_ONE_UPDATES_THE_OTHER_3_get, ContingencyType_ONE_UPDATES_THE_OTHER_3_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EmailType_NEW",EmailType_NEW_get, EmailType_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EmailType_REPLY",EmailType_REPLY_get, EmailType_REPLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EmailType_ADMIN_REPLY",EmailType_ADMIN_REPLY_get, EmailType_ADMIN_REPLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EmailType_ADMINREPLY",EmailType_ADMINREPLY_get, EmailType_ADMINREPLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQltyInd_MEDIUM",IOIQltyInd_MEDIUM_get, IOIQltyInd_MEDIUM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQltyInd_HIGH",IOIQltyInd_HIGH_get, IOIQltyInd_HIGH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQltyInd_LOW",IOIQltyInd_LOW_get, IOIQltyInd_LOW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultiLegRptTypeReq_REPORT_BY_INSTRUMENT_LEGS_BELONGING_TO_THE_MULTILEG_SECURITY_ONLY",MultiLegRptTypeReq_REPORT_BY_INSTRUMENT_LEGS_BELONGING_TO_THE_MULTILEG_SECURITY_ONLY_get, 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",MultiLegRptTypeReq_REPORT_BY_MULTILEG_SECURITY_AND_BY_INSTRUMENT_LEGS_BELONGING_TO_THE_MULTILEG_SECURITY_get, 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",MultiLegRptTypeReq_REPORT_BY_MULITLEG_SECURITY_ONLY_get, MultiLegRptTypeReq_REPORT_BY_MULITLEG_SECURITY_ONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AccountType_ACCOUNTCUSTOMER",AccountType_ACCOUNTCUSTOMER_get, AccountType_ACCOUNTCUSTOMER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AccountType_HOUSE_TRADER",AccountType_HOUSE_TRADER_get, AccountType_HOUSE_TRADER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_THE_BOOKS",AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_THE_BOOKS_get, 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",AccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_get, AccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AccountType_FLOOR_TRADER",AccountType_FLOOR_TRADER_get, AccountType_FLOOR_TRADER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AccountType_JOINT_BACK_OFFICE_ACCOUNT",AccountType_JOINT_BACK_OFFICE_ACCOUNT_get, AccountType_JOINT_BACK_OFFICE_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AccountType_HOUSETRADER",AccountType_HOUSETRADER_get, AccountType_HOUSETRADER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AccountType_FLOORTRADER",AccountType_FLOORTRADER_get, AccountType_FLOORTRADER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AccountType_ACCOUNTNONCUSTOMERCROSS",AccountType_ACCOUNTNONCUSTOMERCROSS_get, AccountType_ACCOUNTNONCUSTOMERCROSS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED",AccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED_get, AccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AccountType_ACCOUNTNONCUSTOMER",AccountType_ACCOUNTNONCUSTOMER_get, AccountType_ACCOUNTNONCUSTOMER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_BOOKS",AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_BOOKS_get, AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_BOOKS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AccountType_HOUSETRADERCROSS",AccountType_HOUSETRADERCROSS_get, AccountType_HOUSETRADERCROSS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AccountType_JOINTBOACCT",AccountType_JOINTBOACCT_get, AccountType_JOINTBOACCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AccountType_JOINT_BACKOFFICE_ACCOUNT",AccountType_JOINT_BACKOFFICE_ACCOUNT_get, AccountType_JOINT_BACKOFFICE_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED",AccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED_get, AccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HaltReasonInt_ADDITIONAL_INFORMATION",HaltReasonInt_ADDITIONAL_INFORMATION_get, HaltReasonInt_ADDITIONAL_INFORMATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HaltReasonInt_NEWS_PENDING",HaltReasonInt_NEWS_PENDING_get, HaltReasonInt_NEWS_PENDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HaltReasonInt_ORDER_INFLUX",HaltReasonInt_ORDER_INFLUX_get, HaltReasonInt_ORDER_INFLUX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HaltReasonInt_NEWS_DISSEMINATION",HaltReasonInt_NEWS_DISSEMINATION_get, HaltReasonInt_NEWS_DISSEMINATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HaltReasonInt_EQUIPMENT_CHANGEOVER",HaltReasonInt_EQUIPMENT_CHANGEOVER_get, HaltReasonInt_EQUIPMENT_CHANGEOVER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HaltReasonInt_ORDER_IMBALANCE",HaltReasonInt_ORDER_IMBALANCE_get, HaltReasonInt_ORDER_IMBALANCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_3RDYEARDELEGATE",ClearingFeeIndicator_3RDYEARDELEGATE_get, ClearingFeeIndicator_3RDYEARDELEGATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_FULLASSOCIATEMEMBER",ClearingFeeIndicator_FULLASSOCIATEMEMBER_get, ClearingFeeIndicator_FULLASSOCIATEMEMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_106H_AND_106J_FIRMS",ClearingFeeIndicator_106H_AND_106J_FIRMS_get, ClearingFeeIndicator_106H_AND_106J_FIRMS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_4THYEARDELEGATE",ClearingFeeIndicator_4THYEARDELEGATE_get, ClearingFeeIndicator_4THYEARDELEGATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_5THYEARDELEGATE",ClearingFeeIndicator_5THYEARDELEGATE_get, ClearingFeeIndicator_5THYEARDELEGATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_EQUITYCLEARINGMEMBER",ClearingFeeIndicator_EQUITYCLEARINGMEMBER_get, ClearingFeeIndicator_EQUITYCLEARINGMEMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_GIMIDEMCOMMEMBERSHIP",ClearingFeeIndicator_GIMIDEMCOMMEMBERSHIP_get, ClearingFeeIndicator_GIMIDEMCOMMEMBERSHIP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_2NDYEARDELEGATE",ClearingFeeIndicator_2NDYEARDELEGATE_get, ClearingFeeIndicator_2NDYEARDELEGATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT",ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_get, ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_1STYEARDELEGATE",ClearingFeeIndicator_1STYEARDELEGATE_get, ClearingFeeIndicator_1STYEARDELEGATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_106H106J",ClearingFeeIndicator_106H106J_get, ClearingFeeIndicator_106H106J_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_GIM_IDEM_AND_COM_MEMBERSHIP_INTEREST_HOLDERS",ClearingFeeIndicator_GIM_IDEM_AND_COM_MEMBERSHIP_INTEREST_HOLDERS_get, ClearingFeeIndicator_GIM_IDEM_AND_COM_MEMBERSHIP_INTEREST_HOLDERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_2ND_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT",ClearingFeeIndicator_2ND_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_get, ClearingFeeIndicator_2ND_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_4TH_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT",ClearingFeeIndicator_4TH_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_get, ClearingFeeIndicator_4TH_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_3RD_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT",ClearingFeeIndicator_3RD_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get, ClearingFeeIndicator_3RD_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_LESSEE_106F_EMPLOYEES",ClearingFeeIndicator_LESSEE_106F_EMPLOYEES_get, ClearingFeeIndicator_LESSEE_106F_EMPLOYEES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_6THYEARDELEGATE",ClearingFeeIndicator_6THYEARDELEGATE_get, ClearingFeeIndicator_6THYEARDELEGATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_NON_MEMBER_AND_CUSTOMER",ClearingFeeIndicator_NON_MEMBER_AND_CUSTOMER_get, ClearingFeeIndicator_NON_MEMBER_AND_CUSTOMER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_5TH_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT",ClearingFeeIndicator_5TH_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_get, 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",ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER_TRADING_FOR_OWN_ACCOUNT_AND_AS_FLOOR_BROKERS_get, ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER_TRADING_FOR_OWN_ACCOUNT_AND_AS_FLOOR_BROKERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_CBOE_MEMBER",ClearingFeeIndicator_CBOE_MEMBER_get, ClearingFeeIndicator_CBOE_MEMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT",ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get, ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_5TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT",ClearingFeeIndicator_5TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get, ClearingFeeIndicator_5TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_NONMEMBERCUSTOMER",ClearingFeeIndicator_NONMEMBERCUSTOMER_get, ClearingFeeIndicator_NONMEMBERCUSTOMER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_LESSEE_AND_106F_EMPLOYEES",ClearingFeeIndicator_LESSEE_AND_106F_EMPLOYEES_get, ClearingFeeIndicator_LESSEE_AND_106F_EMPLOYEES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER_TRADING_FOR_OWN_ACCOUNT_AND_AS_FLOOR",ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER_TRADING_FOR_OWN_ACCOUNT_AND_AS_FLOOR_get, 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",ClearingFeeIndicator_3RD_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_get, ClearingFeeIndicator_3RD_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_2ND_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT",ClearingFeeIndicator_2ND_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get, ClearingFeeIndicator_2ND_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_CBOEMEMBER",ClearingFeeIndicator_CBOEMEMBER_get, ClearingFeeIndicator_CBOEMEMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_LESSEE106F",ClearingFeeIndicator_LESSEE106F_get, ClearingFeeIndicator_LESSEE106F_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_ALLOTHERS",ClearingFeeIndicator_ALLOTHERS_get, ClearingFeeIndicator_ALLOTHERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_EQUITY_MEMBER_AND_CLEARING_MEMBER",ClearingFeeIndicator_EQUITY_MEMBER_AND_CLEARING_MEMBER_get, ClearingFeeIndicator_EQUITY_MEMBER_AND_CLEARING_MEMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_ALL_OTHER_OWNERSHIP_TYPES",ClearingFeeIndicator_ALL_OTHER_OWNERSHIP_TYPES_get, ClearingFeeIndicator_ALL_OTHER_OWNERSHIP_TYPES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_6TH_YEAR_AND_BEYOND_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT",ClearingFeeIndicator_6TH_YEAR_AND_BEYOND_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_get, 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",ClearingFeeIndicator_4TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get, ClearingFeeIndicator_4TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_6TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT",ClearingFeeIndicator_6TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get, ClearingFeeIndicator_6TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidType_DISCLOSED_STYLE",BidType_DISCLOSED_STYLE_get, BidType_DISCLOSED_STYLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidType_NONDISC",BidType_NONDISC_get, BidType_NONDISC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidType_NO_BIDDING_PROCESS",BidType_NO_BIDDING_PROCESS_get, BidType_NO_BIDDING_PROCESS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidType_DISC",BidType_DISC_get, BidType_DISC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidType_DISCLOSED_SYTLE",BidType_DISCLOSED_SYTLE_get, BidType_DISCLOSED_SYTLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidType_NOBID",BidType_NOBID_get, BidType_NOBID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidType_NON_DISCLOSED_STYLE",BidType_NON_DISCLOSED_STYLE_get, BidType_NON_DISCLOSED_STYLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuotePriceType_PER_SHARE",QuotePriceType_PER_SHARE_get, QuotePriceType_PER_SHARE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuotePriceType_BASISPOINTSRELATIVETOBENCHMARK",QuotePriceType_BASISPOINTSRELATIVETOBENCHMARK_get, QuotePriceType_BASISPOINTSRELATIVETOBENCHMARK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuotePriceType_TEDPRICE",QuotePriceType_TEDPRICE_get, QuotePriceType_TEDPRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuotePriceType_PERSHARE",QuotePriceType_PERSHARE_get, QuotePriceType_PERSHARE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuotePriceType_YIELD",QuotePriceType_YIELD_get, QuotePriceType_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuotePriceType_FIXED_AMOUNT",QuotePriceType_FIXED_AMOUNT_get, QuotePriceType_FIXED_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuotePriceType_TED_YIELD",QuotePriceType_TED_YIELD_get, QuotePriceType_TED_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuotePriceType_PREMIUM",QuotePriceType_PREMIUM_get, QuotePriceType_PREMIUM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuotePriceType_FIXEDAMOUNT",QuotePriceType_FIXEDAMOUNT_get, QuotePriceType_FIXEDAMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuotePriceType_YIELDSPREADSWAPS",QuotePriceType_YIELDSPREADSWAPS_get, QuotePriceType_YIELDSPREADSWAPS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuotePriceType_TEDYIELD",QuotePriceType_TEDYIELD_get, QuotePriceType_TEDYIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuotePriceType_DISCOUNT",QuotePriceType_DISCOUNT_get, QuotePriceType_DISCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuotePriceType_YIELD_SPREAD",QuotePriceType_YIELD_SPREAD_get, QuotePriceType_YIELD_SPREAD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuotePriceType_TED_PRICE",QuotePriceType_TED_PRICE_get, QuotePriceType_TED_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuotePriceType_PERCENT",QuotePriceType_PERCENT_get, QuotePriceType_PERCENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuotePriceType_SPREAD",QuotePriceType_SPREAD_get, QuotePriceType_SPREAD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultilegPriceMethod_CONTRACT_WEIGHTED_AVERAGE_PRICE",MultilegPriceMethod_CONTRACT_WEIGHTED_AVERAGE_PRICE_get, MultilegPriceMethod_CONTRACT_WEIGHTED_AVERAGE_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultilegPriceMethod_REVERSED_NET_PRICE",MultilegPriceMethod_REVERSED_NET_PRICE_get, MultilegPriceMethod_REVERSED_NET_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultilegPriceMethod_MULTIPLIED_PRICE",MultilegPriceMethod_MULTIPLIED_PRICE_get, MultilegPriceMethod_MULTIPLIED_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultilegPriceMethod_INDIVIDUAL",MultilegPriceMethod_INDIVIDUAL_get, MultilegPriceMethod_INDIVIDUAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultilegPriceMethod_YIELD_DIFFERENCE",MultilegPriceMethod_YIELD_DIFFERENCE_get, MultilegPriceMethod_YIELD_DIFFERENCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultilegPriceMethod_NET_PRICE",MultilegPriceMethod_NET_PRICE_get, MultilegPriceMethod_NET_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListMethod_PRE_LISTED_ONLY",ListMethod_PRE_LISTED_ONLY_get, ListMethod_PRE_LISTED_ONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListMethod_USER_REQUESTED",ListMethod_USER_REQUESTED_get, ListMethod_USER_REQUESTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDImplicitDelete_NO",MDImplicitDelete_NO_get, MDImplicitDelete_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDImplicitDelete_YES",MDImplicitDelete_YES_get, MDImplicitDelete_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RoutingType_BLOCKLIST",RoutingType_BLOCKLIST_get, RoutingType_BLOCKLIST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RoutingType_TARGET_LIST",RoutingType_TARGET_LIST_get, RoutingType_TARGET_LIST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RoutingType_TARGET_FIRM",RoutingType_TARGET_FIRM_get, RoutingType_TARGET_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RoutingType_TARGETFIRM",RoutingType_TARGETFIRM_get, RoutingType_TARGETFIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RoutingType_TARGETLIST",RoutingType_TARGETLIST_get, RoutingType_TARGETLIST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RoutingType_BLOCK_LIST",RoutingType_BLOCK_LIST_get, RoutingType_BLOCK_LIST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RoutingType_BLOCK_FIRM",RoutingType_BLOCK_FIRM_get, RoutingType_BLOCK_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RoutingType_BLOCKFIRM",RoutingType_BLOCKFIRM_get, RoutingType_BLOCKFIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidTradeType_RISKTRADE",BidTradeType_RISKTRADE_get, BidTradeType_RISKTRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidTradeType_VWAPGUARANTEE",BidTradeType_VWAPGUARANTEE_get, BidTradeType_VWAPGUARANTEE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidTradeType_AGENCY",BidTradeType_AGENCY_get, BidTradeType_AGENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidTradeType_GUARANTEEDCLOSE",BidTradeType_GUARANTEEDCLOSE_get, BidTradeType_GUARANTEEDCLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidTradeType_VWAP_GUARANTEE",BidTradeType_VWAP_GUARANTEE_get, BidTradeType_VWAP_GUARANTEE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidTradeType_RISK_TRADE",BidTradeType_RISK_TRADE_get, BidTradeType_RISK_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidTradeType_GUARANTEED_CLOSE",BidTradeType_GUARANTEED_CLOSE_get, BidTradeType_GUARANTEED_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_INCORRECT_ALLOCATED_QUANTITY",OrdRejReason_INCORRECT_ALLOCATED_QUANTITY_get, OrdRejReason_INCORRECT_ALLOCATED_QUANTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_DUPLICATE_OF_A_VERBALLY_COMMUNICATED_ORDER",OrdRejReason_DUPLICATE_OF_A_VERBALLY_COMMUNICATED_ORDER_get, OrdRejReason_DUPLICATE_OF_A_VERBALLY_COMMUNICATED_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_DUPLICATEVERBAL",OrdRejReason_DUPLICATEVERBAL_get, OrdRejReason_DUPLICATEVERBAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_ORDER_EXCEEDS_LIMIT",OrdRejReason_ORDER_EXCEEDS_LIMIT_get, OrdRejReason_ORDER_EXCEEDS_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_EXCHANGE_CLOSED",OrdRejReason_EXCHANGE_CLOSED_get, OrdRejReason_EXCHANGE_CLOSED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_DUPLICATE",OrdRejReason_DUPLICATE_get, OrdRejReason_DUPLICATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_SURVEILLENCE_OPTION",OrdRejReason_SURVEILLENCE_OPTION_get, OrdRejReason_SURVEILLENCE_OPTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_UNKNOWN_ORDER",OrdRejReason_UNKNOWN_ORDER_get, OrdRejReason_UNKNOWN_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_INCORRECTALLOCATEDQUANTITY",OrdRejReason_INCORRECTALLOCATEDQUANTITY_get, OrdRejReason_INCORRECTALLOCATEDQUANTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_TOOLATE",OrdRejReason_TOOLATE_get, OrdRejReason_TOOLATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC",OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC_get, OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_DUPLICATE_ORDER",OrdRejReason_DUPLICATE_ORDER_get, OrdRejReason_DUPLICATE_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_TOO_LATE_TO_ENTER",OrdRejReason_TOO_LATE_TO_ENTER_get, OrdRejReason_TOO_LATE_TO_ENTER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_INCORRECT_QUANTITY",OrdRejReason_INCORRECT_QUANTITY_get, OrdRejReason_INCORRECT_QUANTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_UNKNOWNSYM",OrdRejReason_UNKNOWNSYM_get, OrdRejReason_UNKNOWNSYM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_STALE",OrdRejReason_STALE_get, OrdRejReason_STALE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_UNKNOWN_ACCOUNT",OrdRejReason_UNKNOWN_ACCOUNT_get, OrdRejReason_UNKNOWN_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_INVALID_PRICE_INCREMENT",OrdRejReason_INVALID_PRICE_INCREMENT_get, OrdRejReason_INVALID_PRICE_INCREMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_BROKEROPT",OrdRejReason_BROKEROPT_get, OrdRejReason_BROKEROPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_EXCEEDSLIM",OrdRejReason_EXCEEDSLIM_get, OrdRejReason_EXCEEDSLIM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_INVALID_INVESTOR_ID",OrdRejReason_INVALID_INVESTOR_ID_get, OrdRejReason_INVALID_INVESTOR_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_UNKNOWN_SYMBOL",OrdRejReason_UNKNOWN_SYMBOL_get, OrdRejReason_UNKNOWN_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_INCORRECTQUANTITY",OrdRejReason_INCORRECTQUANTITY_get, OrdRejReason_INCORRECTQUANTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_UNKNOWNACCOUNTS",OrdRejReason_UNKNOWNACCOUNTS_get, OrdRejReason_UNKNOWNACCOUNTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_OTHER",OrdRejReason_OTHER_get, OrdRejReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_BROKER",OrdRejReason_BROKER_get, OrdRejReason_BROKER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_BROKER_OPTION",OrdRejReason_BROKER_OPTION_get, OrdRejReason_BROKER_OPTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_SURVEILLENCE",OrdRejReason_SURVEILLENCE_get, OrdRejReason_SURVEILLENCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_EXCHCLOSED",OrdRejReason_EXCHCLOSED_get, OrdRejReason_EXCHCLOSED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND",OrdRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_get, OrdRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_INVINVID",OrdRejReason_INVINVID_get, OrdRejReason_INVINVID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_UNSUPPORDERCHAR",OrdRejReason_UNSUPPORDERCHAR_get, OrdRejReason_UNSUPPORDERCHAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_TRADEALONGREQ",OrdRejReason_TRADEALONGREQ_get, OrdRejReason_TRADEALONGREQ_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_UNKNOWN",OrdRejReason_UNKNOWN_get, OrdRejReason_UNKNOWN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_TRADE_ALONG_REQUIRED",OrdRejReason_TRADE_ALONG_REQUIRED_get, OrdRejReason_TRADE_ALONG_REQUIRED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_STALE_ORDER",OrdRejReason_STALE_ORDER_get, OrdRejReason_STALE_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MaturityMonthYearIncrementUnits_WEEKS",MaturityMonthYearIncrementUnits_WEEKS_get, MaturityMonthYearIncrementUnits_WEEKS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MaturityMonthYearIncrementUnits_MONTHS",MaturityMonthYearIncrementUnits_MONTHS_get, MaturityMonthYearIncrementUnits_MONTHS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MaturityMonthYearIncrementUnits_YEARS",MaturityMonthYearIncrementUnits_YEARS_get, MaturityMonthYearIncrementUnits_YEARS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MaturityMonthYearIncrementUnits_DAYS",MaturityMonthYearIncrementUnits_DAYS_get, MaturityMonthYearIncrementUnits_DAYS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DisplayWhen_EXHAUST",DisplayWhen_EXHAUST_get, DisplayWhen_EXHAUST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DisplayWhen_IMMEDIATE",DisplayWhen_IMMEDIATE_get, DisplayWhen_IMMEDIATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplQueueAction_END_SESSION",ApplQueueAction_END_SESSION_get, ApplQueueAction_END_SESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplQueueAction_QUEUEFLUSHED",ApplQueueAction_QUEUEFLUSHED_get, ApplQueueAction_QUEUEFLUSHED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplQueueAction_QUEUE_FLUSHED",ApplQueueAction_QUEUE_FLUSHED_get, ApplQueueAction_QUEUE_FLUSHED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplQueueAction_ENDSESSION",ApplQueueAction_ENDSESSION_get, ApplQueueAction_ENDSESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplQueueAction_OVERLAYLAST",ApplQueueAction_OVERLAYLAST_get, ApplQueueAction_OVERLAYLAST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplQueueAction_OVERLAY_LAST",ApplQueueAction_OVERLAY_LAST_get, ApplQueueAction_OVERLAY_LAST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplQueueAction_NOACTIONTAKEN",ApplQueueAction_NOACTIONTAKEN_get, ApplQueueAction_NOACTIONTAKEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplQueueAction_NO_ACTION_TAKEN",ApplQueueAction_NO_ACTION_TAKEN_get, ApplQueueAction_NO_ACTION_TAKEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistTransType_REPLACE",RegistTransType_REPLACE_get, RegistTransType_REPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistTransType_NEW",RegistTransType_NEW_get, RegistTransType_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistTransType_CANCEL",RegistTransType_CANCEL_get, RegistTransType_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_PRODUCT_TICKS_IN_HALFS",PriceType_PRODUCT_TICKS_IN_HALFS_get, PriceType_PRODUCT_TICKS_IN_HALFS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_FIXEDCABINETTRADEPRICE",PriceType_FIXEDCABINETTRADEPRICE_get, PriceType_FIXEDCABINETTRADEPRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_PER_SHARE",PriceType_PER_SHARE_get, PriceType_PER_SHARE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_PCT",PriceType_PCT_get, PriceType_PCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_VARIABLECABINETTRADEPRICE",PriceType_VARIABLECABINETTRADEPRICE_get, PriceType_VARIABLECABINETTRADEPRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_PRODUCT_TICKS_IN_FOURTHS",PriceType_PRODUCT_TICKS_IN_FOURTHS_get, PriceType_PRODUCT_TICKS_IN_FOURTHS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_TEDPRICE",PriceType_TEDPRICE_get, PriceType_TEDPRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_YIELD",PriceType_YIELD_get, PriceType_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_TED_YIELD",PriceType_TED_YIELD_get, PriceType_TED_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_PREMIUM",PriceType_PREMIUM_get, PriceType_PREMIUM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_FIXED_AMOUNT",PriceType_FIXED_AMOUNT_get, PriceType_FIXED_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_TEDYIELD",PriceType_TEDYIELD_get, PriceType_TEDYIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_DISCOUNT",PriceType_DISCOUNT_get, PriceType_DISCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_PRODUCT_TICKS_IN_SIXTY_FORTHS",PriceType_PRODUCT_TICKS_IN_SIXTY_FORTHS_get, PriceType_PRODUCT_TICKS_IN_SIXTY_FORTHS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTS",PriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTS_get, PriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_CPS",PriceType_CPS_get, PriceType_CPS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_PERCENTAGE",PriceType_PERCENTAGE_get, PriceType_PERCENTAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_PRODUCT_TICKS_IN_EIGHTS",PriceType_PRODUCT_TICKS_IN_EIGHTS_get, PriceType_PRODUCT_TICKS_IN_EIGHTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_PRODUCT_TICKS_IN_THIRTY_SECONDS",PriceType_PRODUCT_TICKS_IN_THIRTY_SECONDS_get, PriceType_PRODUCT_TICKS_IN_THIRTY_SECONDS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_ABS",PriceType_ABS_get, PriceType_ABS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_VARIABLE_CABINET_TRADE_PRICE",PriceType_VARIABLE_CABINET_TRADE_PRICE_get, PriceType_VARIABLE_CABINET_TRADE_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_PER_UNIT",PriceType_PER_UNIT_get, PriceType_PER_UNIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_PRODUCT_TICKS_IN_SIXTEENTHS",PriceType_PRODUCT_TICKS_IN_SIXTEENTHS_get, PriceType_PRODUCT_TICKS_IN_SIXTEENTHS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_TED_PRICE",PriceType_TED_PRICE_get, PriceType_TED_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_FIXED_CABINET_TRADE_PRICE",PriceType_FIXED_CABINET_TRADE_PRICE_get, PriceType_FIXED_CABINET_TRADE_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_SPREAD",PriceType_SPREAD_get, PriceType_SPREAD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_BASIS_POINTS_RELATIVE_TO_BENCHMARK",PriceType_BASIS_POINTS_RELATIVE_TO_BENCHMARK_get, PriceType_BASIS_POINTS_RELATIVE_TO_BENCHMARK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlObligMode_PRELIMINARY",SettlObligMode_PRELIMINARY_get, SettlObligMode_PRELIMINARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlObligMode_FINAL",SettlObligMode_FINAL_get, SettlObligMode_FINAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityUpdateAction_DELETE",SecurityUpdateAction_DELETE_get, SecurityUpdateAction_DELETE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityUpdateAction_ADD",SecurityUpdateAction_ADD_get, SecurityUpdateAction_ADD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityUpdateAction_MODIFY",SecurityUpdateAction_MODIFY_get, SecurityUpdateAction_MODIFY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NetworkRequestType_STOP_SUBSCRIBING",NetworkRequestType_STOP_SUBSCRIBING_get, NetworkRequestType_STOP_SUBSCRIBING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NetworkRequestType_LEVELOFDETAIL",NetworkRequestType_LEVELOFDETAIL_get, NetworkRequestType_LEVELOFDETAIL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NetworkRequestType_SUBSCRIBE",NetworkRequestType_SUBSCRIBE_get, NetworkRequestType_SUBSCRIBE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NetworkRequestType_SNAPSHOT",NetworkRequestType_SNAPSHOT_get, NetworkRequestType_SNAPSHOT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NetworkRequestType_STOPSUBSCRIBING",NetworkRequestType_STOPSUBSCRIBING_get, NetworkRequestType_STOPSUBSCRIBING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NetworkRequestType_LEVEL_OF_DETAIL_THEN_NOCOMPIDS_BECOMES_REQUIRED",NetworkRequestType_LEVEL_OF_DETAIL_THEN_NOCOMPIDS_BECOMES_REQUIRED_get, NetworkRequestType_LEVEL_OF_DETAIL_THEN_NOCOMPIDS_BECOMES_REQUIRED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_TRADER_MNEMONIC",PartyRole_TRADER_MNEMONIC_get, PartyRole_TRADER_MNEMONIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_ACCEPTABLE_COUNTERPARTY",PartyRole_ACCEPTABLE_COUNTERPARTY_get, PartyRole_ACCEPTABLE_COUNTERPARTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_HOST_COMPETENT_AUTHORITY",PartyRole_HOST_COMPETENT_AUTHORITY_get, PartyRole_HOST_COMPETENT_AUTHORITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CONTRATRADER",PartyRole_CONTRATRADER_get, PartyRole_CONTRATRADER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_EXECUTINGFIRM",PartyRole_EXECUTINGFIRM_get, PartyRole_EXECUTINGFIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CUSTOMER_ACCOUNT",PartyRole_CUSTOMER_ACCOUNT_get, PartyRole_CUSTOMER_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_POSITIONACCOUNT",PartyRole_POSITIONACCOUNT_get, PartyRole_POSITIONACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_REPORT_ORIGINATOR",PartyRole_REPORT_ORIGINATOR_get, PartyRole_REPORT_ORIGINATOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CONTRAFIRM",PartyRole_CONTRAFIRM_get, PartyRole_CONTRAFIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_EXECUTION_VENUE",PartyRole_EXECUTION_VENUE_get, PartyRole_EXECUTION_VENUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_INTERMEDIARY",PartyRole_INTERMEDIARY_get, PartyRole_INTERMEDIARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_ORDER_ENTRY_OPERATOR_ID",PartyRole_ORDER_ENTRY_OPERATOR_ID_get, PartyRole_ORDER_ENTRY_OPERATOR_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_INTRODUCING_BROKER",PartyRole_INTRODUCING_BROKER_get, PartyRole_INTRODUCING_BROKER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_FOREIGN_FIRM",PartyRole_FOREIGN_FIRM_get, PartyRole_FOREIGN_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_HOME_COMPETENT_AUTHORITY",PartyRole_HOME_COMPETENT_AUTHORITY_get, PartyRole_HOME_COMPETENT_AUTHORITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_EXECUTINGSYSTEM",PartyRole_EXECUTINGSYSTEM_get, PartyRole_EXECUTINGSYSTEM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_SECONDARY_ACCOUNT_NUMBER",PartyRole_SECONDARY_ACCOUNT_NUMBER_get, PartyRole_SECONDARY_ACCOUNT_NUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_INVESTMENT_FIRM",PartyRole_INVESTMENT_FIRM_get, PartyRole_INVESTMENT_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CONTRA_CLEARING_FIRM",PartyRole_CONTRA_CLEARING_FIRM_get, PartyRole_CONTRA_CLEARING_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CONTRA_POSITION_ACCOUNT",PartyRole_CONTRA_POSITION_ACCOUNT_get, PartyRole_CONTRA_POSITION_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_SYSTEMATIC_INTERNALISER",PartyRole_SYSTEMATIC_INTERNALISER_get, PartyRole_SYSTEMATIC_INTERNALISER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_EXCHANGE",PartyRole_EXCHANGE_get, PartyRole_EXCHANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_INTERNAL_CARRY_ACCOUNT",PartyRole_INTERNAL_CARRY_ACCOUNT_get, PartyRole_INTERNAL_CARRY_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_LOCATE",PartyRole_LOCATE_get, PartyRole_LOCATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CORRESPONDENTCLEARINGORGANIZATION",PartyRole_CORRESPONDENTCLEARINGORGANIZATION_get, PartyRole_CORRESPONDENTCLEARINGORGANIZATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_ORDER_ORIGINATION_TRADER",PartyRole_ORDER_ORIGINATION_TRADER_get, PartyRole_ORDER_ORIGINATION_TRADER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_SUB_CUSTODIAN",PartyRole_SUB_CUSTODIAN_get, PartyRole_SUB_CUSTODIAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_ENTERING_UNIT",PartyRole_ENTERING_UNIT_get, PartyRole_ENTERING_UNIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_STEP_OUT_FIRM",PartyRole_STEP_OUT_FIRM_get, PartyRole_STEP_OUT_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_COMPETENT_AUTHORITY_OF_THE_TRANSACTION",PartyRole_COMPETENT_AUTHORITY_OF_THE_TRANSACTION_get, PartyRole_COMPETENT_AUTHORITY_OF_THE_TRANSACTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_SENDER_LOCATION",PartyRole_SENDER_LOCATION_get, PartyRole_SENDER_LOCATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_REGULATED_MARKET",PartyRole_REGULATED_MARKET_get, PartyRole_REGULATED_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_UNACCEPTABLE_SETTLING_COUNTERPARTY",PartyRole_UNACCEPTABLE_SETTLING_COUNTERPARTY_get, PartyRole_UNACCEPTABLE_SETTLING_COUNTERPARTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_SETTLEMENTLOCATION",PartyRole_SETTLEMENTLOCATION_get, PartyRole_SETTLEMENTLOCATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_COMPETENT_AUTHORITY_OF_THE_MOST_RELEVANT_MARKET_IN_TERMS_OF_LIQUIDITY",PartyRole_COMPETENT_AUTHORITY_OF_THE_MOST_RELEVANT_MARKET_IN_TERMS_OF_LIQUIDITY_get, PartyRole_COMPETENT_AUTHORITY_OF_THE_MOST_RELEVANT_MARKET_IN_TERMS_OF_LIQUIDITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_QUOTE_ORIGINATOR",PartyRole_QUOTE_ORIGINATOR_get, PartyRole_QUOTE_ORIGINATOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CLEARING_ORGANIZATION",PartyRole_CLEARING_ORGANIZATION_get, PartyRole_CLEARING_ORGANIZATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_SESSION_ID",PartyRole_SESSION_ID_get, PartyRole_SESSION_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_MARKET_MAKER",PartyRole_MARKET_MAKER_get, PartyRole_MARKET_MAKER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_INTERESTED_PARTY",PartyRole_INTERESTED_PARTY_get, PartyRole_INTERESTED_PARTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_TRANSFER_TO_FIRM",PartyRole_TRANSFER_TO_FIRM_get, PartyRole_TRANSFER_TO_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CONTRA_TRADER",PartyRole_CONTRA_TRADER_get, PartyRole_CONTRA_TRADER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_ENTERINGTRADER",PartyRole_ENTERINGTRADER_get, PartyRole_ENTERINGTRADER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_ENTERING_TRADER",PartyRole_ENTERING_TRADER_get, PartyRole_ENTERING_TRADER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_LARGE_TRADER_REPORTABLE_ACCOUNT",PartyRole_LARGE_TRADER_REPORTABLE_ACCOUNT_get, PartyRole_LARGE_TRADER_REPORTABLE_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_BENEFICIARY",PartyRole_BENEFICIARY_get, PartyRole_BENEFICIARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CONTRA_INVESTOR_ID",PartyRole_CONTRA_INVESTOR_ID_get, PartyRole_CONTRA_INVESTOR_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_FORIEGN_FIRM",PartyRole_FORIEGN_FIRM_get, PartyRole_FORIEGN_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_SETTLEMENT_LOCATION",PartyRole_SETTLEMENT_LOCATION_get, PartyRole_SETTLEMENT_LOCATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CLEARINGORGANIZATION",PartyRole_CLEARINGORGANIZATION_get, PartyRole_CLEARINGORGANIZATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_EXECUTING_SYSTEM",PartyRole_EXECUTING_SYSTEM_get, PartyRole_EXECUTING_SYSTEM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CLEARING_FIRM",PartyRole_CLEARING_FIRM_get, PartyRole_CLEARING_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_PLEDGEE_ACCOUNT",PartyRole_PLEDGEE_ACCOUNT_get, PartyRole_PLEDGEE_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CLIENT_ID",PartyRole_CLIENT_ID_get, PartyRole_CLIENT_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_ENTERING_FIRM",PartyRole_ENTERING_FIRM_get, PartyRole_ENTERING_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_ALLOCENTITY",PartyRole_ALLOCENTITY_get, PartyRole_ALLOCENTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_INVESTOR_ID",PartyRole_INVESTOR_ID_get, PartyRole_INVESTOR_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CLEARINGFIRM",PartyRole_CLEARINGFIRM_get, PartyRole_CLEARINGFIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CORRESPONDANT_CLEARING_FIRM",PartyRole_CORRESPONDANT_CLEARING_FIRM_get, PartyRole_CORRESPONDANT_CLEARING_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_SUBCUSTODIAN",PartyRole_SUBCUSTODIAN_get, PartyRole_SUBCUSTODIAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_BUYER_SELLER",PartyRole_BUYER_SELLER_get, PartyRole_BUYER_SELLER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CLEARING_ACCOUNT",PartyRole_CLEARING_ACCOUNT_get, PartyRole_CLEARING_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_ENTERINGFIRM",PartyRole_ENTERINGFIRM_get, PartyRole_ENTERINGFIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_PRIME_BROKER_PROVIDING_GENERAL_TRADE_SERVICES",PartyRole_PRIME_BROKER_PROVIDING_GENERAL_TRADE_SERVICES_get, PartyRole_PRIME_BROKER_PROVIDING_GENERAL_TRADE_SERVICES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CORRESPONDENT_CLEARING_ORGANIZATION",PartyRole_CORRESPONDENT_CLEARING_ORGANIZATION_get, PartyRole_CORRESPONDENT_CLEARING_ORGANIZATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_ACCEPTABLE_SETTLING_COUNTERPARTY",PartyRole_ACCEPTABLE_SETTLING_COUNTERPARTY_get, PartyRole_ACCEPTABLE_SETTLING_COUNTERPARTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CUSTOMERACCOUNT",PartyRole_CUSTOMERACCOUNT_get, PartyRole_CUSTOMERACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_MARKET_DATA_ENTRY_ORIGINATOR",PartyRole_MARKET_DATA_ENTRY_ORIGINATOR_get, PartyRole_MARKET_DATA_ENTRY_ORIGINATOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_INTRODUCINGFIRM",PartyRole_INTRODUCINGFIRM_get, PartyRole_INTRODUCINGFIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_EXECUTING_UNIT",PartyRole_EXECUTING_UNIT_get, PartyRole_EXECUTING_UNIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CENTRAL_REGISTRATION_DEPOSITORY",PartyRole_CENTRAL_REGISTRATION_DEPOSITORY_get, PartyRole_CENTRAL_REGISTRATION_DEPOSITORY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_INTERESTEDPARTY",PartyRole_INTERESTEDPARTY_get, PartyRole_INTERESTEDPARTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_LOCATION_ID",PartyRole_LOCATION_ID_get, PartyRole_LOCATION_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_ORDERORIGINATOR",PartyRole_ORDERORIGINATOR_get, PartyRole_ORDERORIGINATOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CORRESPONDENT_BROKER",PartyRole_CORRESPONDENT_BROKER_get, PartyRole_CORRESPONDENT_BROKER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_ASSET_MANAGER",PartyRole_ASSET_MANAGER_get, PartyRole_ASSET_MANAGER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_MULTILATERAL_TRADING_FACILITY",PartyRole_MULTILATERAL_TRADING_FACILITY_get, PartyRole_MULTILATERAL_TRADING_FACILITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_SPONSORINGFIRM",PartyRole_SPONSORINGFIRM_get, PartyRole_SPONSORINGFIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_ORDER_ORIGINATION_FIRM",PartyRole_ORDER_ORIGINATION_FIRM_get, PartyRole_ORDER_ORIGINATION_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CONTRA_EXCHANGE",PartyRole_CONTRA_EXCHANGE_get, PartyRole_CONTRA_EXCHANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_INVESTORID",PartyRole_INVESTORID_get, PartyRole_INVESTORID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_FUNDMANAGER",PartyRole_FUNDMANAGER_get, PartyRole_FUNDMANAGER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_REGULATORYBODY",PartyRole_REGULATORYBODY_get, PartyRole_REGULATORYBODY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CONTRA_FIRM",PartyRole_CONTRA_FIRM_get, PartyRole_CONTRA_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_BROKER_OF_CREDIT",PartyRole_BROKER_OF_CREDIT_get, PartyRole_BROKER_OF_CREDIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_LIQUIDITYPROVIDER",PartyRole_LIQUIDITYPROVIDER_get, PartyRole_LIQUIDITYPROVIDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_GIVEUPCLEARINGFIRM",PartyRole_GIVEUPCLEARINGFIRM_get, PartyRole_GIVEUPCLEARINGFIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CONTRACLEARINGFIRM",PartyRole_CONTRACLEARINGFIRM_get, PartyRole_CONTRACLEARINGFIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CLAIMING_ACCOUNT",PartyRole_CLAIMING_ACCOUNT_get, PartyRole_CLAIMING_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_INTRODUCING_FIRM",PartyRole_INTRODUCING_FIRM_get, PartyRole_INTRODUCING_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_GIVEUP_CLEARING_FIRM",PartyRole_GIVEUP_CLEARING_FIRM_get, PartyRole_GIVEUP_CLEARING_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_EXECUTINGTRADER",PartyRole_EXECUTINGTRADER_get, PartyRole_EXECUTINGTRADER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_UNDERLYING_CONTRA_FIRM",PartyRole_UNDERLYING_CONTRA_FIRM_get, PartyRole_UNDERLYING_CONTRA_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_EXECUTING_FIRM",PartyRole_EXECUTING_FIRM_get, PartyRole_EXECUTING_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_AGENT",PartyRole_AGENT_get, PartyRole_AGENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_LIQUIDITY_PROVIDER",PartyRole_LIQUIDITY_PROVIDER_get, PartyRole_LIQUIDITY_PROVIDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_POSITION_ACCOUNT",PartyRole_POSITION_ACCOUNT_get, PartyRole_POSITION_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_BROKEROFCREDIT",PartyRole_BROKEROFCREDIT_get, PartyRole_BROKEROFCREDIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_THIRD_PARTY_ALLOCATION_FIRM",PartyRole_THIRD_PARTY_ALLOCATION_FIRM_get, PartyRole_THIRD_PARTY_ALLOCATION_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CLIENTID",PartyRole_CLIENTID_get, PartyRole_CLIENTID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_PLEDGOR_ACCOUNT",PartyRole_PLEDGOR_ACCOUNT_get, PartyRole_PLEDGOR_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_REPORTING_INTERMEDIARY",PartyRole_REPORTING_INTERMEDIARY_get, PartyRole_REPORTING_INTERMEDIARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_EXECUTING_TRADER",PartyRole_EXECUTING_TRADER_get, PartyRole_EXECUTING_TRADER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CUSTODIAN",PartyRole_CUSTODIAN_get, PartyRole_CUSTODIAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_BROKERCLEARINGID",PartyRole_BROKERCLEARINGID_get, PartyRole_BROKERCLEARINGID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CORRESPONDENTBROKER",PartyRole_CORRESPONDENTBROKER_get, PartyRole_CORRESPONDENTBROKER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_LOCATE_LENDING_FIRM",PartyRole_LOCATE_LENDING_FIRM_get, PartyRole_LOCATE_LENDING_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_INITIATINGTRADER",PartyRole_INITIATINGTRADER_get, PartyRole_INITIATINGTRADER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_REGULATORY_BODY",PartyRole_REGULATORY_BODY_get, PartyRole_REGULATORY_BODY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_UNACCEPTABLE_COUNTERPARTY",PartyRole_UNACCEPTABLE_COUNTERPARTY_get, PartyRole_UNACCEPTABLE_COUNTERPARTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CORRESPONDANTCLEARINGFIRM",PartyRole_CORRESPONDANTCLEARINGFIRM_get, PartyRole_CORRESPONDANTCLEARINGFIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_FUND_MANAGER_CLIENT_ID",PartyRole_FUND_MANAGER_CLIENT_ID_get, PartyRole_FUND_MANAGER_CLIENT_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_BUYERSELLERRECEIVERDELIVERER",PartyRole_BUYERSELLERRECEIVERDELIVERER_get, PartyRole_BUYERSELLERRECEIVERDELIVERER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_DESK_ID",PartyRole_DESK_ID_get, PartyRole_DESK_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_ALLOCATION_ENTITY",PartyRole_ALLOCATION_ENTITY_get, PartyRole_ALLOCATION_ENTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_MARKET_DATA_MARKET",PartyRole_MARKET_DATA_MARKET_get, PartyRole_MARKET_DATA_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_SPONSORING_FIRM",PartyRole_SPONSORING_FIRM_get, PartyRole_SPONSORING_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_LOCATELENDINGFIRM",PartyRole_LOCATELENDINGFIRM_get, PartyRole_LOCATELENDINGFIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_UNDRCONTRAFIRM",PartyRole_UNDRCONTRAFIRM_get, PartyRole_UNDRCONTRAFIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AssignmentMethod_PRO_RATA",AssignmentMethod_PRO_RATA_get, AssignmentMethod_PRO_RATA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AssignmentMethod_RANDOM",AssignmentMethod_RANDOM_get, AssignmentMethod_RANDOM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AssignmentMethod_PRORATA",AssignmentMethod_PRORATA_get, AssignmentMethod_PRORATA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_MONTHYEAR",StrategyParameterType_MONTHYEAR_get, StrategyParameterType_MONTHYEAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_TZTIMEONLY",StrategyParameterType_TZTIMEONLY_get, StrategyParameterType_TZTIMEONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_PRICE",StrategyParameterType_PRICE_get, StrategyParameterType_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_QTY",StrategyParameterType_QTY_get, StrategyParameterType_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_BOOLEAN",StrategyParameterType_BOOLEAN_get, StrategyParameterType_BOOLEAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_MULTIPLECHARVALUE",StrategyParameterType_MULTIPLECHARVALUE_get, StrategyParameterType_MULTIPLECHARVALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_CHAR",StrategyParameterType_CHAR_get, StrategyParameterType_CHAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_NUMINGROUP",StrategyParameterType_NUMINGROUP_get, StrategyParameterType_NUMINGROUP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_TAGNUM",StrategyParameterType_TAGNUM_get, StrategyParameterType_TAGNUM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_COUNTRY",StrategyParameterType_COUNTRY_get, StrategyParameterType_COUNTRY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_TENOR",StrategyParameterType_TENOR_get, StrategyParameterType_TENOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_LOCALMKTTIME",StrategyParameterType_LOCALMKTTIME_get, StrategyParameterType_LOCALMKTTIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_INT",StrategyParameterType_INT_get, StrategyParameterType_INT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_LOCALMKTDATE",StrategyParameterType_LOCALMKTDATE_get, StrategyParameterType_LOCALMKTDATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_EXCHANGE",StrategyParameterType_EXCHANGE_get, StrategyParameterType_EXCHANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_LANGUAGE",StrategyParameterType_LANGUAGE_get, StrategyParameterType_LANGUAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_MONTH_YEAR",StrategyParameterType_MONTH_YEAR_get, StrategyParameterType_MONTH_YEAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_PERCENTAGE",StrategyParameterType_PERCENTAGE_get, StrategyParameterType_PERCENTAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_LENGTH",StrategyParameterType_LENGTH_get, StrategyParameterType_LENGTH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_TZTIMESTAMP",StrategyParameterType_TZTIMESTAMP_get, StrategyParameterType_TZTIMESTAMP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_MULTIPLESTRINGVALUE",StrategyParameterType_MULTIPLESTRINGVALUE_get, StrategyParameterType_MULTIPLESTRINGVALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_UTCTIMESTAMP",StrategyParameterType_UTCTIMESTAMP_get, StrategyParameterType_UTCTIMESTAMP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_DATA",StrategyParameterType_DATA_get, StrategyParameterType_DATA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_CURRENCY",StrategyParameterType_CURRENCY_get, StrategyParameterType_CURRENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_STRING",StrategyParameterType_STRING_get, StrategyParameterType_STRING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_AMT",StrategyParameterType_AMT_get, StrategyParameterType_AMT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_FLOAT",StrategyParameterType_FLOAT_get, StrategyParameterType_FLOAT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_UTCDATE",StrategyParameterType_UTCDATE_get, StrategyParameterType_UTCDATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_UTCTIMEONLY",StrategyParameterType_UTCTIMEONLY_get, StrategyParameterType_UTCTIMEONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_SEQNUM",StrategyParameterType_SEQNUM_get, StrategyParameterType_SEQNUM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_UTCDATEONLY",StrategyParameterType_UTCDATEONLY_get, StrategyParameterType_UTCDATEONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_PRICEOFFSET",StrategyParameterType_PRICEOFFSET_get, StrategyParameterType_PRICEOFFSET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EncryptMethod_PGP_DES_MD5",EncryptMethod_PGP_DES_MD5_get, EncryptMethod_PGP_DES_MD5_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EncryptMethod_PGPDESMD5SEEAPPNOTEONFIXWEBSITE",EncryptMethod_PGPDESMD5SEEAPPNOTEONFIXWEBSITE_get, EncryptMethod_PGPDESMD5SEEAPPNOTEONFIXWEBSITE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EncryptMethod_PKCS_DES",EncryptMethod_PKCS_DES_get, EncryptMethod_PKCS_DES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EncryptMethod_NONEOTHER",EncryptMethod_NONEOTHER_get, EncryptMethod_NONEOTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EncryptMethod_PKCSDESPROPRIETARY",EncryptMethod_PKCSDESPROPRIETARY_get, EncryptMethod_PKCSDESPROPRIETARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EncryptMethod_PGPDESDEFUNCT",EncryptMethod_PGPDESDEFUNCT_get, EncryptMethod_PGPDESDEFUNCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EncryptMethod_PEMDESMD5SEEAPPNOTEONFIXWEBSITENAFORFIXMLNOTUSED",EncryptMethod_PEMDESMD5SEEAPPNOTEONFIXWEBSITENAFORFIXMLNOTUSED_get, EncryptMethod_PEMDESMD5SEEAPPNOTEONFIXWEBSITENAFORFIXMLNOTUSED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EncryptMethod_PKCS",EncryptMethod_PKCS_get, EncryptMethod_PKCS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EncryptMethod_PGP_DES",EncryptMethod_PGP_DES_get, EncryptMethod_PGP_DES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EncryptMethod_NONE",EncryptMethod_NONE_get, EncryptMethod_NONE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EncryptMethod_DES",EncryptMethod_DES_get, EncryptMethod_DES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EncryptMethod_PKCSPROPRIETARY",EncryptMethod_PKCSPROPRIETARY_get, EncryptMethod_PKCSPROPRIETARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EncryptMethod_NONE_OTHER",EncryptMethod_NONE_OTHER_get, EncryptMethod_NONE_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EncryptMethod_DESECBMODE",EncryptMethod_DESECBMODE_get, EncryptMethod_DESECBMODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EncryptMethod_PEM_DES_MD5",EncryptMethod_PEM_DES_MD5_get, EncryptMethod_PEM_DES_MD5_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_ACCRUED_COUPON_AMOUNT",PosAmtType_ACCRUED_COUPON_AMOUNT_get, PosAmtType_ACCRUED_COUPON_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_PREMIUM_AMOUNT",PosAmtType_PREMIUM_AMOUNT_get, PosAmtType_PREMIUM_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_STARTOFDAYMARKTOMARKETAMOUNT",PosAmtType_STARTOFDAYMARKTOMARKETAMOUNT_get, PosAmtType_STARTOFDAYMARKTOMARKETAMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_INCREMENTALMARKTOMARKETAMOUNT",PosAmtType_INCREMENTALMARKTOMARKETAMOUNT_get, PosAmtType_INCREMENTALMARKTOMARKETAMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_CASHAMOUNTCORPORATEEVENT",PosAmtType_CASHAMOUNTCORPORATEEVENT_get, PosAmtType_CASHAMOUNTCORPORATEEVENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_INCREMENTAL_COLLATERALIZED_MARK_TO_MARKET",PosAmtType_INCREMENTAL_COLLATERALIZED_MARK_TO_MARKET_get, PosAmtType_INCREMENTAL_COLLATERALIZED_MARK_TO_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_TOTAL_BANKED_AMOUNT",PosAmtType_TOTAL_BANKED_AMOUNT_get, PosAmtType_TOTAL_BANKED_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_FINAL_MARK_TO_MARKET_AMOUNT",PosAmtType_FINAL_MARK_TO_MARKET_AMOUNT_get, PosAmtType_FINAL_MARK_TO_MARKET_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_SETTLEMENT_VALUE",PosAmtType_SETTLEMENT_VALUE_get, PosAmtType_SETTLEMENT_VALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_VALUEADJUSTEDAMOUNT",PosAmtType_VALUEADJUSTEDAMOUNT_get, PosAmtType_VALUEADJUSTEDAMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_CASH_AMOUNT",PosAmtType_CASH_AMOUNT_get, PosAmtType_CASH_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_PREMIUMAMOUNT",PosAmtType_PREMIUMAMOUNT_get, PosAmtType_PREMIUMAMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_INITIAL_TRADE_COUPON_AMOUNT",PosAmtType_INITIAL_TRADE_COUPON_AMOUNT_get, PosAmtType_INITIAL_TRADE_COUPON_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_INCREMENTAL_ACCRUED_COUPON",PosAmtType_INCREMENTAL_ACCRUED_COUPON_get, PosAmtType_INCREMENTAL_ACCRUED_COUPON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_START_OF_DAY_MARK_TO_MARKET_AMOUNT",PosAmtType_START_OF_DAY_MARK_TO_MARKET_AMOUNT_get, PosAmtType_START_OF_DAY_MARK_TO_MARKET_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_VALUE_ADJUSTED_AMOUNT",PosAmtType_VALUE_ADJUSTED_AMOUNT_get, PosAmtType_VALUE_ADJUSTED_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_CASHRESIDUALAMOUNT",PosAmtType_CASHRESIDUALAMOUNT_get, PosAmtType_CASHRESIDUALAMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_COLLATERALIZED_MARK_TO_MARKET",PosAmtType_COLLATERALIZED_MARK_TO_MARKET_get, PosAmtType_COLLATERALIZED_MARK_TO_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_CASH_RESIDUAL_AMOUNT",PosAmtType_CASH_RESIDUAL_AMOUNT_get, PosAmtType_CASH_RESIDUAL_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_COMPENSATION_AMOUNT",PosAmtType_COMPENSATION_AMOUNT_get, PosAmtType_COMPENSATION_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_TRADE_VARIATION_AMOUNT",PosAmtType_TRADE_VARIATION_AMOUNT_get, PosAmtType_TRADE_VARIATION_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_TRADEVARIATIONAMOUNT",PosAmtType_TRADEVARIATIONAMOUNT_get, PosAmtType_TRADEVARIATIONAMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_FINALMARKTOMARKETAMOUNT",PosAmtType_FINALMARKTOMARKETAMOUNT_get, PosAmtType_FINALMARKTOMARKETAMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_COUPON_AMOUNT",PosAmtType_COUPON_AMOUNT_get, PosAmtType_COUPON_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_TOTAL_COLLATERALIZED_AMOUNT",PosAmtType_TOTAL_COLLATERALIZED_AMOUNT_get, PosAmtType_TOTAL_COLLATERALIZED_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_INCREMENTAL_MARK_TO_MARKET_AMOUNT",PosAmtType_INCREMENTAL_MARK_TO_MARKET_AMOUNT_get, PosAmtType_INCREMENTAL_MARK_TO_MARKET_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ResetSeqNumFlag_NO",ResetSeqNumFlag_NO_get, ResetSeqNumFlag_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ResetSeqNumFlag_YES",ResetSeqNumFlag_YES_get, ResetSeqNumFlag_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_ORDER_SPECIFIED",CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_ORDER_SPECIFIED_get, CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_ORDER_SPECIFIED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryResult_NOCOLLATERALFOUNDFORTHEORDERSPECIFIED",CollInquiryResult_NOCOLLATERALFOUNDFORTHEORDERSPECIFIED_get, CollInquiryResult_NOCOLLATERALFOUNDFORTHEORDERSPECIFIED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryResult_NOCOLLATERALFOUNDFORTHETRADESPECIFIED",CollInquiryResult_NOCOLLATERALFOUNDFORTHETRADESPECIFIED_get, CollInquiryResult_NOCOLLATERALFOUNDFORTHETRADESPECIFIED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryResult_INVALIDORUNKNOWNINSTRUMENT",CollInquiryResult_INVALIDORUNKNOWNINSTRUMENT_get, CollInquiryResult_INVALIDORUNKNOWNINSTRUMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryResult_INVALID_DESTINATION_REQUESTED",CollInquiryResult_INVALID_DESTINATION_REQUESTED_get, CollInquiryResult_INVALID_DESTINATION_REQUESTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryResult_INVALIDORUNKNOWNCOLLATERALTYPE",CollInquiryResult_INVALIDORUNKNOWNCOLLATERALTYPE_get, CollInquiryResult_INVALIDORUNKNOWNCOLLATERALTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryResult_UNAUTHORIZED_FOR_COLLATERAL_INQUIRY",CollInquiryResult_UNAUTHORIZED_FOR_COLLATERAL_INQUIRY_get, CollInquiryResult_UNAUTHORIZED_FOR_COLLATERAL_INQUIRY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryResult_INVALIDTRANSPORTTYPEREQUESTED",CollInquiryResult_INVALIDTRANSPORTTYPEREQUESTED_get, CollInquiryResult_INVALIDTRANSPORTTYPEREQUESTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryResult_INVALIDPARTIES",CollInquiryResult_INVALIDPARTIES_get, CollInquiryResult_INVALIDPARTIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryResult_INVALID_OR_UNKNOWN_COLLATERAL_TYPE",CollInquiryResult_INVALID_OR_UNKNOWN_COLLATERAL_TYPE_get, CollInquiryResult_INVALID_OR_UNKNOWN_COLLATERAL_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryResult_INVALIDDESTINATIONREQUESTED",CollInquiryResult_INVALIDDESTINATIONREQUESTED_get, CollInquiryResult_INVALIDDESTINATIONREQUESTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryResult_SUCCESSFUL",CollInquiryResult_SUCCESSFUL_get, CollInquiryResult_SUCCESSFUL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryResult_INVALID_OR_UNKNOWN_INSTRUMENT",CollInquiryResult_INVALID_OR_UNKNOWN_INSTRUMENT_get, CollInquiryResult_INVALID_OR_UNKNOWN_INSTRUMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryResult_COLLATERAL_INQUIRY_TYPE_NOT_SUPPORTED",CollInquiryResult_COLLATERAL_INQUIRY_TYPE_NOT_SUPPORTED_get, CollInquiryResult_COLLATERAL_INQUIRY_TYPE_NOT_SUPPORTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryResult_OTHER",CollInquiryResult_OTHER_get, CollInquiryResult_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryResult_UNAUTHORIZEDFORCOLLATERALINQUIRY",CollInquiryResult_UNAUTHORIZEDFORCOLLATERALINQUIRY_get, CollInquiryResult_UNAUTHORIZEDFORCOLLATERALINQUIRY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryResult_COLLATERALINQUIRYTYPENOTSUPPORTED",CollInquiryResult_COLLATERALINQUIRYTYPENOTSUPPORTED_get, CollInquiryResult_COLLATERALINQUIRYTYPENOTSUPPORTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryResult_INVALID_PARTIES",CollInquiryResult_INVALID_PARTIES_get, CollInquiryResult_INVALID_PARTIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryResult_INVALID_TRANSPORT_TYPE_REQUESTED",CollInquiryResult_INVALID_TRANSPORT_TYPE_REQUESTED_get, CollInquiryResult_INVALID_TRANSPORT_TYPE_REQUESTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_TRADE_SPECIFIED",CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_TRADE_SPECIFIED_get, CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_TRADE_SPECIFIED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnRespType_DECLINED",CollAsgnRespType_DECLINED_get, CollAsgnRespType_DECLINED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnRespType_RECEIVED",CollAsgnRespType_RECEIVED_get, CollAsgnRespType_RECEIVED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnRespType_REJECTED",CollAsgnRespType_REJECTED_get, CollAsgnRespType_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnRespType_ACCEPTED",CollAsgnRespType_ACCEPTED_get, CollAsgnRespType_ACCEPTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnsolicitedIndicator_NO",UnsolicitedIndicator_NO_get, UnsolicitedIndicator_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnsolicitedIndicator_YES",UnsolicitedIndicator_YES_get, UnsolicitedIndicator_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryRejectReason_UNKNWNSYM",QuoteEntryRejectReason_UNKNWNSYM_get, QuoteEntryRejectReason_UNKNWNSYM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryRejectReason_EXCHCLSD",QuoteEntryRejectReason_EXCHCLSD_get, QuoteEntryRejectReason_EXCHCLSD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryRejectReason_EXHCNAGE",QuoteEntryRejectReason_EXHCNAGE_get, QuoteEntryRejectReason_EXHCNAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryRejectReason_DUPORD",QuoteEntryRejectReason_DUPORD_get, QuoteEntryRejectReason_DUPORD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryRejectReason_INVALID_PRICE",QuoteEntryRejectReason_INVALID_PRICE_get, QuoteEntryRejectReason_INVALID_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryRejectReason_TOOLATE",QuoteEntryRejectReason_TOOLATE_get, QuoteEntryRejectReason_TOOLATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryRejectReason_INVBIDASK",QuoteEntryRejectReason_INVBIDASK_get, QuoteEntryRejectReason_INVBIDASK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY",QuoteEntryRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY_get, QuoteEntryRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryRejectReason_TOO_LATE_TO_ENTER",QuoteEntryRejectReason_TOO_LATE_TO_ENTER_get, QuoteEntryRejectReason_TOO_LATE_TO_ENTER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryRejectReason_QUOTE_EXCEEDS_LIMIT",QuoteEntryRejectReason_QUOTE_EXCEEDS_LIMIT_get, QuoteEntryRejectReason_QUOTE_EXCEEDS_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryRejectReason_ORDEXCLIM",QuoteEntryRejectReason_ORDEXCLIM_get, QuoteEntryRejectReason_ORDEXCLIM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryRejectReason_UNKNORD",QuoteEntryRejectReason_UNKNORD_get, QuoteEntryRejectReason_UNKNORD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryRejectReason_INVPX",QuoteEntryRejectReason_INVPX_get, QuoteEntryRejectReason_INVPX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryRejectReason_EXCHANGE",QuoteEntryRejectReason_EXCHANGE_get, QuoteEntryRejectReason_EXCHANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryRejectReason_UNKNOWN_SYMBOL",QuoteEntryRejectReason_UNKNOWN_SYMBOL_get, QuoteEntryRejectReason_UNKNOWN_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryRejectReason_NOTAUTH",QuoteEntryRejectReason_NOTAUTH_get, QuoteEntryRejectReason_NOTAUTH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryRejectReason_OTHER",QuoteEntryRejectReason_OTHER_get, QuoteEntryRejectReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryRejectReason_INVALID_BID_ASK_SPREAD",QuoteEntryRejectReason_INVALID_BID_ASK_SPREAD_get, QuoteEntryRejectReason_INVALID_BID_ASK_SPREAD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryRejectReason_UNKNOWN_QUOTE",QuoteEntryRejectReason_UNKNOWN_QUOTE_get, QuoteEntryRejectReason_UNKNOWN_QUOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryRejectReason_DUPLICATE_QUOTE",QuoteEntryRejectReason_DUPLICATE_QUOTE_get, QuoteEntryRejectReason_DUPLICATE_QUOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderCapacity_PROPRIETARY",OrderCapacity_PROPRIETARY_get, OrderCapacity_PROPRIETARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderCapacity_RISKLESS_PRINCIPAL",OrderCapacity_RISKLESS_PRINCIPAL_get, OrderCapacity_RISKLESS_PRINCIPAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderCapacity_AGENT_FOR_OTHER_MEMBER",OrderCapacity_AGENT_FOR_OTHER_MEMBER_get, OrderCapacity_AGENT_FOR_OTHER_MEMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderCapacity_PRINCIPAL",OrderCapacity_PRINCIPAL_get, OrderCapacity_PRINCIPAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderCapacity_AGENCY",OrderCapacity_AGENCY_get, OrderCapacity_AGENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderCapacity_INDIVIDUAL",OrderCapacity_INDIVIDUAL_get, OrderCapacity_INDIVIDUAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderCapacity_AGENTOTHERMEMBER",OrderCapacity_AGENTOTHERMEMBER_get, OrderCapacity_AGENTOTHERMEMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderCapacity_RISKLESSPRINCIPAL",OrderCapacity_RISKLESSPRINCIPAL_get, OrderCapacity_RISKLESSPRINCIPAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteAckStatus_CANCELED_FOR_UNDERLYING",QuoteAckStatus_CANCELED_FOR_UNDERLYING_get, QuoteAckStatus_CANCELED_FOR_UNDERLYING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteAckStatus_CANCELED_ALL",QuoteAckStatus_CANCELED_ALL_get, QuoteAckStatus_CANCELED_ALL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteAckStatus_CANCELED_FOR_SECURITY_TYPE",QuoteAckStatus_CANCELED_FOR_SECURITY_TYPE_get, QuoteAckStatus_CANCELED_FOR_SECURITY_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteAckStatus_REJECTED",QuoteAckStatus_REJECTED_get, QuoteAckStatus_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteAckStatus_CANCELED_FOR_SYMBOL",QuoteAckStatus_CANCELED_FOR_SYMBOL_get, QuoteAckStatus_CANCELED_FOR_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteAckStatus_ACCEPTED",QuoteAckStatus_ACCEPTED_get, QuoteAckStatus_ACCEPTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserRequestType_CHANGE_PASSWORD_FOR_USER",UserRequestType_CHANGE_PASSWORD_FOR_USER_get, UserRequestType_CHANGE_PASSWORD_FOR_USER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserRequestType_CHANGEPASSWORDFORUSER",UserRequestType_CHANGEPASSWORDFORUSER_get, UserRequestType_CHANGEPASSWORDFORUSER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserRequestType_LOGOFFUSER",UserRequestType_LOGOFFUSER_get, UserRequestType_LOGOFFUSER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserRequestType_LOG_OFF_USER",UserRequestType_LOG_OFF_USER_get, UserRequestType_LOG_OFF_USER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserRequestType_REQUEST_INDIVIDUAL_USER_STATUS",UserRequestType_REQUEST_INDIVIDUAL_USER_STATUS_get, UserRequestType_REQUEST_INDIVIDUAL_USER_STATUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserRequestType_REQUESTINDIVIDUALUSERSTATUS",UserRequestType_REQUESTINDIVIDUALUSERSTATUS_get, UserRequestType_REQUESTINDIVIDUALUSERSTATUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserRequestType_LOGONUSER",UserRequestType_LOGONUSER_get, UserRequestType_LOGONUSER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserRequestType_LOG_ON_USER",UserRequestType_LOG_ON_USER_get, UserRequestType_LOG_ON_USER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportTransType_REPLACE",TradeReportTransType_REPLACE_get, TradeReportTransType_REPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportTransType_NEW",TradeReportTransType_NEW_get, TradeReportTransType_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportTransType_REVERSE",TradeReportTransType_REVERSE_get, TradeReportTransType_REVERSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportTransType_CANCEL",TradeReportTransType_CANCEL_get, TradeReportTransType_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportTransType_CANCEL_DUE_TO_BACK_OUT_OF_TRADE",TradeReportTransType_CANCEL_DUE_TO_BACK_OUT_OF_TRADE_get, TradeReportTransType_CANCEL_DUE_TO_BACK_OUT_OF_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportTransType_RELEASE",TradeReportTransType_RELEASE_get, TradeReportTransType_RELEASE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AdvSide_CROSS",AdvSide_CROSS_get, AdvSide_CROSS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AdvSide_TRADE",AdvSide_TRADE_get, AdvSide_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AdvSide_BUY",AdvSide_BUY_get, AdvSide_BUY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AdvSide_SELL",AdvSide_SELL_get, AdvSide_SELL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CoveredOrUncovered_COVERED",CoveredOrUncovered_COVERED_get, CoveredOrUncovered_COVERED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CoveredOrUncovered_UNCOVERED",CoveredOrUncovered_UNCOVERED_get, CoveredOrUncovered_UNCOVERED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AcctIDSource_TFMGSPTA",AcctIDSource_TFMGSPTA_get, AcctIDSource_TFMGSPTA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AcctIDSource_TFM",AcctIDSource_TFM_get, AcctIDSource_TFM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AcctIDSource_DTCCCODE",AcctIDSource_DTCCCODE_get, AcctIDSource_DTCCCODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AcctIDSource_SIDCODE",AcctIDSource_SIDCODE_get, AcctIDSource_SIDCODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AcctIDSource_OMGEOALERTID",AcctIDSource_OMGEOALERTID_get, AcctIDSource_OMGEOALERTID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AcctIDSource_BIC",AcctIDSource_BIC_get, AcctIDSource_BIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AcctIDSource_OTHER",AcctIDSource_OTHER_get, AcctIDSource_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AcctIDSource_OMGEO",AcctIDSource_OMGEO_get, AcctIDSource_OMGEO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AcctIDSource_SID_CODE",AcctIDSource_SID_CODE_get, AcctIDSource_SID_CODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AcctIDSource_DTCC_CODE",AcctIDSource_DTCC_CODE_get, AcctIDSource_DTCC_CODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestType_UNMATCHED_TRADES_THAT_MATCH_CRITERIA",TradeRequestType_UNMATCHED_TRADES_THAT_MATCH_CRITERIA_get, TradeRequestType_UNMATCHED_TRADES_THAT_MATCH_CRITERIA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestType_ALL_TRADES",TradeRequestType_ALL_TRADES_get, TradeRequestType_ALL_TRADES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestType_MATCHED_TRADES_MATCHING_CRITERIA_PROVIDED_ON_REQUEST",TradeRequestType_MATCHED_TRADES_MATCHING_CRITERIA_PROVIDED_ON_REQUEST_get, TradeRequestType_MATCHED_TRADES_MATCHING_CRITERIA_PROVIDED_ON_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestType_UNREPORTEDTRADES",TradeRequestType_UNREPORTEDTRADES_get, TradeRequestType_UNREPORTEDTRADES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestType_ALLTRADES",TradeRequestType_ALLTRADES_get, TradeRequestType_ALLTRADES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestType_ADVISORIESMATCH",TradeRequestType_ADVISORIESMATCH_get, TradeRequestType_ADVISORIESMATCH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestType_MATCHEDTRADES",TradeRequestType_MATCHEDTRADES_get, TradeRequestType_MATCHEDTRADES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestType_UNMATCHEDTRADES",TradeRequestType_UNMATCHEDTRADES_get, TradeRequestType_UNMATCHEDTRADES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestType_UNREPORTED_TRADES_THAT_MATCH_CRITERIA",TradeRequestType_UNREPORTED_TRADES_THAT_MATCH_CRITERIA_get, TradeRequestType_UNREPORTED_TRADES_THAT_MATCH_CRITERIA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestType_ADVISORIES_THAT_MATCH_CRITERIA",TradeRequestType_ADVISORIES_THAT_MATCH_CRITERIA_get, TradeRequestType_ADVISORIES_THAT_MATCH_CRITERIA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesStatus_PRECLOSE",TradSesStatus_PRECLOSE_get, TradSesStatus_PRECLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesStatus_HALTED",TradSesStatus_HALTED_get, TradSesStatus_HALTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesStatus_REQREJ",TradSesStatus_REQREJ_get, TradSesStatus_REQREJ_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesStatus_REQUEST_REJECTED",TradSesStatus_REQUEST_REJECTED_get, TradSesStatus_REQUEST_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesStatus_OPEN",TradSesStatus_OPEN_get, TradSesStatus_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesStatus_PREOPEN",TradSesStatus_PREOPEN_get, TradSesStatus_PREOPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesStatus_PRE_OPEN",TradSesStatus_PRE_OPEN_get, TradSesStatus_PRE_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesStatus_UNKNOWN",TradSesStatus_UNKNOWN_get, TradSesStatus_UNKNOWN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesStatus_PRE_CLOSE",TradSesStatus_PRE_CLOSE_get, TradSesStatus_PRE_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesStatus_CLOSED",TradSesStatus_CLOSED_get, TradSesStatus_CLOSED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegPriceType_LAST_PEG",PegPriceType_LAST_PEG_get, PegPriceType_LAST_PEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegPriceType_PRIMARY_PEG",PegPriceType_PRIMARY_PEG_get, PegPriceType_PRIMARY_PEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegPriceType_OPENING_PEG",PegPriceType_OPENING_PEG_get, PegPriceType_OPENING_PEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegPriceType_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER",PegPriceType_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER_get, PegPriceType_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegPriceType_TRAILING_STOP_PEG",PegPriceType_TRAILING_STOP_PEG_get, PegPriceType_TRAILING_STOP_PEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegPriceType_PEG_TO_LIMIT_PRICE",PegPriceType_PEG_TO_LIMIT_PRICE_get, PegPriceType_PEG_TO_LIMIT_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegPriceType_MID_PRICE_PEG",PegPriceType_MID_PRICE_PEG_get, PegPriceType_MID_PRICE_PEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegPriceType_MARKET_PEG",PegPriceType_MARKET_PEG_get, PegPriceType_MARKET_PEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegPriceType_PEG_TO_VWAP",PegPriceType_PEG_TO_VWAP_get, PegPriceType_PEG_TO_VWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StreamAsgnRejReason_NO_AVAILABLE_STREAM",StreamAsgnRejReason_NO_AVAILABLE_STREAM_get, StreamAsgnRejReason_NO_AVAILABLE_STREAM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StreamAsgnRejReason_EXCEEDS_MAXIMUM_SIZE",StreamAsgnRejReason_EXCEEDS_MAXIMUM_SIZE_get, StreamAsgnRejReason_EXCEEDS_MAXIMUM_SIZE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StreamAsgnRejReason_UNKNOWN_CLIENT",StreamAsgnRejReason_UNKNOWN_CLIENT_get, StreamAsgnRejReason_UNKNOWN_CLIENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StreamAsgnRejReason_UNKNOWN_OR_INVALID_CURRENCY_PAIR",StreamAsgnRejReason_UNKNOWN_OR_INVALID_CURRENCY_PAIR_get, StreamAsgnRejReason_UNKNOWN_OR_INVALID_CURRENCY_PAIR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StreamAsgnRejReason_OTHER",StreamAsgnRejReason_OTHER_get, StreamAsgnRejReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT",ValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT_get, ValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ValuationMethod_PREMIUM_STYLE",ValuationMethod_PREMIUM_STYLE_get, ValuationMethod_PREMIUM_STYLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ValuationMethod_CDS_IN_DELIVERY",ValuationMethod_CDS_IN_DELIVERY_get, ValuationMethod_CDS_IN_DELIVERY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ValuationMethod_CDS_STYLE_COLLATERALIZATION_OF_MARKET_TO_MARKET_AND_COUPON",ValuationMethod_CDS_STYLE_COLLATERALIZATION_OF_MARKET_TO_MARKET_AND_COUPON_get, ValuationMethod_CDS_STYLE_COLLATERALIZATION_OF_MARKET_TO_MARKET_AND_COUPON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ValuationMethod_FUTURES_STYLE_MARK_TO_MARKET",ValuationMethod_FUTURES_STYLE_MARK_TO_MARKET_get, ValuationMethod_FUTURES_STYLE_MARK_TO_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerType_SPECIFIED_TRADING_SESSION",TriggerType_SPECIFIED_TRADING_SESSION_get, TriggerType_SPECIFIED_TRADING_SESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerType_NEXT_AUCTION",TriggerType_NEXT_AUCTION_get, TriggerType_NEXT_AUCTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerType_PRICE_MOVEMENT",TriggerType_PRICE_MOVEMENT_get, TriggerType_PRICE_MOVEMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerType_PARTIAL_EXECUTION",TriggerType_PARTIAL_EXECUTION_get, TriggerType_PARTIAL_EXECUTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceProtectionScope_LOCAL",PriceProtectionScope_LOCAL_get, PriceProtectionScope_LOCAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceProtectionScope_NONE",PriceProtectionScope_NONE_get, PriceProtectionScope_NONE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceProtectionScope_GLOBAL",PriceProtectionScope_GLOBAL_get, PriceProtectionScope_GLOBAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceProtectionScope_NATIONAL",PriceProtectionScope_NATIONAL_get, PriceProtectionScope_NATIONAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportRejectReason_SUCCESSFULDEFAULT",TradeReportRejectReason_SUCCESSFULDEFAULT_get, TradeReportRejectReason_SUCCESSFULDEFAULT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportRejectReason_UNAUTHORIZED_TO_REPORT_TRADES",TradeReportRejectReason_UNAUTHORIZED_TO_REPORT_TRADES_get, TradeReportRejectReason_UNAUTHORIZED_TO_REPORT_TRADES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportRejectReason_SUCCESSFUL",TradeReportRejectReason_SUCCESSFUL_get, TradeReportRejectReason_SUCCESSFUL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportRejectReason_INVALID_PARTY_ONFORMATION",TradeReportRejectReason_INVALID_PARTY_ONFORMATION_get, TradeReportRejectReason_INVALID_PARTY_ONFORMATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportRejectReason_UNKNOWN_INSTRUMENT",TradeReportRejectReason_UNKNOWN_INSTRUMENT_get, TradeReportRejectReason_UNKNOWN_INSTRUMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportRejectReason_OTHER",TradeReportRejectReason_OTHER_get, TradeReportRejectReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportRejectReason_INVALIDTRADETYPE",TradeReportRejectReason_INVALIDTRADETYPE_get, TradeReportRejectReason_INVALIDTRADETYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportRejectReason_UNKNOWNINSTRUMENT",TradeReportRejectReason_UNKNOWNINSTRUMENT_get, TradeReportRejectReason_UNKNOWNINSTRUMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportRejectReason_INVALID_TRADE_TYPE",TradeReportRejectReason_INVALID_TRADE_TYPE_get, TradeReportRejectReason_INVALID_TRADE_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportRejectReason_UNAUTHORIZEDTOREPORTTRADES",TradeReportRejectReason_UNAUTHORIZEDTOREPORTTRADES_get, TradeReportRejectReason_UNAUTHORIZEDTOREPORTTRADES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportRejectReason_INVALIDPARTYINFORMATION",TradeReportRejectReason_INVALIDPARTYINFORMATION_get, TradeReportRejectReason_INVALIDPARTYINFORMATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityListType_NEWSPAPER_LIST",SecurityListType_NEWSPAPER_LIST_get, SecurityListType_NEWSPAPER_LIST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityListType_TRADING_LIST",SecurityListType_TRADING_LIST_get, SecurityListType_TRADING_LIST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityListType_INDUSTRY_CLASSIFICATION",SecurityListType_INDUSTRY_CLASSIFICATION_get, SecurityListType_INDUSTRY_CLASSIFICATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityListType_MARKET",SecurityListType_MARKET_get, SecurityListType_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_QUOTE_LOCKED",QuoteRejectReason_QUOTE_LOCKED_get, QuoteRejectReason_QUOTE_LOCKED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_UNKNSYM",QuoteRejectReason_UNKNSYM_get, QuoteRejectReason_UNKNSYM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_EXCHCLSD",QuoteRejectReason_EXCHCLSD_get, QuoteRejectReason_EXCHCLSD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_DUPORD",QuoteRejectReason_DUPORD_get, QuoteRejectReason_DUPORD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY",QuoteRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_get, QuoteRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_INVALID_PRICE",QuoteRejectReason_INVALID_PRICE_get, QuoteRejectReason_INVALID_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_TOOLATE",QuoteRejectReason_TOOLATE_get, QuoteRejectReason_TOOLATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY",QuoteRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY_get, QuoteRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_TOO_LATE_TO_ENTER",QuoteRejectReason_TOO_LATE_TO_ENTER_get, QuoteRejectReason_TOO_LATE_TO_ENTER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_UNKNORD",QuoteRejectReason_UNKNORD_get, QuoteRejectReason_UNKNORD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_INVPX",QuoteRejectReason_INVPX_get, QuoteRejectReason_INVPX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_EXCHANGE",QuoteRejectReason_EXCHANGE_get, QuoteRejectReason_EXCHANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_INVSPREAD",QuoteRejectReason_INVSPREAD_get, QuoteRejectReason_INVSPREAD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_UNKNOWN_SYMBOL",QuoteRejectReason_UNKNOWN_SYMBOL_get, QuoteRejectReason_UNKNOWN_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_NOTAUTH",QuoteRejectReason_NOTAUTH_get, QuoteRejectReason_NOTAUTH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_OTHER",QuoteRejectReason_OTHER_get, QuoteRejectReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_INVALID_BID_ASK_SPREAD",QuoteRejectReason_INVALID_BID_ASK_SPREAD_get, QuoteRejectReason_INVALID_BID_ASK_SPREAD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_UNKNOWN_QUOTE",QuoteRejectReason_UNKNOWN_QUOTE_get, QuoteRejectReason_UNKNOWN_QUOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER",QuoteRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_get, QuoteRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_ORDEXLIM",QuoteRejectReason_ORDEXLIM_get, QuoteRejectReason_ORDEXLIM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_DUPLICATE_QUOTE",QuoteRejectReason_DUPLICATE_QUOTE_get, QuoteRejectReason_DUPLICATE_QUOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND",QuoteRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_get, QuoteRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT",QuoteRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT_get, QuoteRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PossResend_NO",PossResend_NO_get, PossResend_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PossResend_YES",PossResend_YES_get, PossResend_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuantityType_SHARES",QuantityType_SHARES_get, QuantityType_SHARES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuantityType_CURRENTFACE",QuantityType_CURRENTFACE_get, QuantityType_CURRENTFACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuantityType_PAR",QuantityType_PAR_get, QuantityType_PAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuantityType_BONDS",QuantityType_BONDS_get, QuantityType_BONDS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuantityType_ORIGINALFACE",QuantityType_ORIGINALFACE_get, QuantityType_ORIGINALFACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuantityType_CONTRACTS",QuantityType_CONTRACTS_get, QuantityType_CONTRACTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuantityType_OTHER",QuantityType_OTHER_get, QuantityType_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuantityType_CURRENCY",QuantityType_CURRENCY_get, QuantityType_CURRENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventPriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE",ComplexEventPriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE_get, ComplexEventPriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventPriceBoundaryMethod_EQUAL_TO_COMPLEXEVENTPRICE",ComplexEventPriceBoundaryMethod_EQUAL_TO_COMPLEXEVENTPRICE_get, ComplexEventPriceBoundaryMethod_EQUAL_TO_COMPLEXEVENTPRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventPriceBoundaryMethod_LESS_THAN_COMPLEXEVENTPRICE",ComplexEventPriceBoundaryMethod_LESS_THAN_COMPLEXEVENTPRICE_get, ComplexEventPriceBoundaryMethod_LESS_THAN_COMPLEXEVENTPRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventPriceBoundaryMethod_GREATER_THAN_COMPLEXEVENTPRICE",ComplexEventPriceBoundaryMethod_GREATER_THAN_COMPLEXEVENTPRICE_get, ComplexEventPriceBoundaryMethod_GREATER_THAN_COMPLEXEVENTPRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventPriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE",ComplexEventPriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE_get, ComplexEventPriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ImpliedMarketIndicator_BOTH_IMPLIED_IN_AND_IMPLIED_OUT",ImpliedMarketIndicator_BOTH_IMPLIED_IN_AND_IMPLIED_OUT_get, ImpliedMarketIndicator_BOTH_IMPLIED_IN_AND_IMPLIED_OUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ImpliedMarketIndicator_NOT_IMPLIED",ImpliedMarketIndicator_NOT_IMPLIED_get, ImpliedMarketIndicator_NOT_IMPLIED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ImpliedMarketIndicator_IMPLIED_OUT",ImpliedMarketIndicator_IMPLIED_OUT_get, ImpliedMarketIndicator_IMPLIED_OUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ImpliedMarketIndicator_IMPLIED_IN",ImpliedMarketIndicator_IMPLIED_IN_get, ImpliedMarketIndicator_IMPLIED_IN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestType_AUTOMATIC",QuoteRequestType_AUTOMATIC_get, QuoteRequestType_AUTOMATIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestType_MAN",QuoteRequestType_MAN_get, QuoteRequestType_MAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestType_AUTO",QuoteRequestType_AUTO_get, QuoteRequestType_AUTO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestType_MANUAL",QuoteRequestType_MANUAL_get, QuoteRequestType_MANUAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestResult_INSTRUMENTUNAVAILABLE",SecurityRequestResult_INSTRUMENTUNAVAILABLE_get, SecurityRequestResult_INSTRUMENTUNAVAILABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestResult_NO_INSTRUMENTS_FOUND_THAT_MATCH_SELECTION_CRITERIA",SecurityRequestResult_NO_INSTRUMENTS_FOUND_THAT_MATCH_SELECTION_CRITERIA_get, SecurityRequestResult_NO_INSTRUMENTS_FOUND_THAT_MATCH_SELECTION_CRITERIA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_INSTRUMENT_DATA",SecurityRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_INSTRUMENT_DATA_get, SecurityRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_INSTRUMENT_DATA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestResult_INSTRUMENT_DATA_TEMPORARILY_UNAVAILABLE",SecurityRequestResult_INSTRUMENT_DATA_TEMPORARILY_UNAVAILABLE_get, SecurityRequestResult_INSTRUMENT_DATA_TEMPORARILY_UNAVAILABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestResult_VALID_REQUEST",SecurityRequestResult_VALID_REQUEST_get, SecurityRequestResult_VALID_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestResult_VALIDREQ",SecurityRequestResult_VALIDREQ_get, SecurityRequestResult_VALIDREQ_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestResult_NOINSTRUMENTSFOUND",SecurityRequestResult_NOINSTRUMENTSFOUND_get, SecurityRequestResult_NOINSTRUMENTSFOUND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestResult_INVALID_OR_UNSUPPORTED_REQUEST",SecurityRequestResult_INVALID_OR_UNSUPPORTED_REQUEST_get, SecurityRequestResult_INVALID_OR_UNSUPPORTED_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestResult_NOTAUTHORIZED",SecurityRequestResult_NOTAUTHORIZED_get, SecurityRequestResult_NOTAUTHORIZED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestResult_NOTSUPPORTED",SecurityRequestResult_NOTSUPPORTED_get, SecurityRequestResult_NOTSUPPORTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestResult_INVALIDREQ",SecurityRequestResult_INVALIDREQ_get, SecurityRequestResult_INVALIDREQ_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestResult_REQUEST_FOR_INSTRUMENT_DATA_NOT_SUPPORTED",SecurityRequestResult_REQUEST_FOR_INSTRUMENT_DATA_NOT_SUPPORTED_get, SecurityRequestResult_REQUEST_FOR_INSTRUMENT_DATA_NOT_SUPPORTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_ISSUER_HOLDING",OrderRestrictions_ISSUER_HOLDING_get, OrderRestrictions_ISSUER_HOLDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_NON_INDEXARBITRAGE",OrderRestrictions_NON_INDEXARBITRAGE_get, OrderRestrictions_NON_INDEXARBITRAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_EXMRKTPART",OrderRestrictions_EXMRKTPART_get, OrderRestrictions_EXMRKTPART_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_SECURITY",OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_SECURITY_get, OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_NON_ALGORITHMIC",OrderRestrictions_NON_ALGORITHMIC_get, OrderRestrictions_NON_ALGORITHMIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_EXTNERAL_INTER_CONNECTED_MARKET_LINKAGE",OrderRestrictions_EXTNERAL_INTER_CONNECTED_MARKET_LINKAGE_get, OrderRestrictions_EXTNERAL_INTER_CONNECTED_MARKET_LINKAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_NON_INDEX_ARBITRAGE",OrderRestrictions_NON_INDEX_ARBITRAGE_get, 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",OrderRestrictions_ACTING_AS_MARKET_MAKER_OF_SPECIALIST_IN_THE_UNDERLYING_SECURITY_OF_A_DERIVATIVE_SEUCIRTY_get, OrderRestrictions_ACTING_AS_MARKET_MAKER_OF_SPECIALIST_IN_THE_UNDERLYING_SECURITY_OF_A_DERIVATIVE_SEUCIRTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_PROGRAM_TRADE",OrderRestrictions_PROGRAM_TRADE_get, OrderRestrictions_PROGRAM_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_ISSUE_PRICE_STABILIZATION",OrderRestrictions_ISSUE_PRICE_STABILIZATION_get, OrderRestrictions_ISSUE_PRICE_STABILIZATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_INDEXARBITRAGE",OrderRestrictions_INDEXARBITRAGE_get, OrderRestrictions_INDEXARBITRAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_ACTMMDERIV",OrderRestrictions_ACTMMDERIV_get, OrderRestrictions_ACTMMDERIV_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_FORENTITY",OrderRestrictions_FORENTITY_get, OrderRestrictions_FORENTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_CROSS",OrderRestrictions_CROSS_get, OrderRestrictions_CROSS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_PROGRAMTRADE",OrderRestrictions_PROGRAMTRADE_get, OrderRestrictions_PROGRAMTRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_RISKARB",OrderRestrictions_RISKARB_get, OrderRestrictions_RISKARB_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_EXTERNAL_INTER_CONNECTED_MARKET_LINKAGE",OrderRestrictions_EXTERNAL_INTER_CONNECTED_MARKET_LINKAGE_get, OrderRestrictions_EXTERNAL_INTER_CONNECTED_MARKET_LINKAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_FOREIGN_ENTITY",OrderRestrictions_FOREIGN_ENTITY_get, OrderRestrictions_FOREIGN_ENTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_COMPETINGMARKETMAKER",OrderRestrictions_COMPETINGMARKETMAKER_get, OrderRestrictions_COMPETINGMARKETMAKER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_EXINTMRKTLINK",OrderRestrictions_EXINTMRKTLINK_get, OrderRestrictions_EXINTMRKTLINK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_INDEX_ARBITRAGE",OrderRestrictions_INDEX_ARBITRAGE_get, OrderRestrictions_INDEX_ARBITRAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_EXTERNAL_MARKET_PARTICIPANT",OrderRestrictions_EXTERNAL_MARKET_PARTICIPANT_get, OrderRestrictions_EXTERNAL_MARKET_PARTICIPANT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_ALGORITHMIC",OrderRestrictions_ALGORITHMIC_get, OrderRestrictions_ALGORITHMIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_ACTMM",OrderRestrictions_ACTMM_get, OrderRestrictions_ACTMM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_UNDERLYING_SECURITY_OF_A_DERIVATIVE_SECURITY",OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_UNDERLYING_SECURITY_OF_A_DERIVATIVE_SECURITY_get, OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_UNDERLYING_SECURITY_OF_A_DERIVATIVE_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_RISKLESS_ARBITRAGE",OrderRestrictions_RISKLESS_ARBITRAGE_get, OrderRestrictions_RISKLESS_ARBITRAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_COMPETING_MARKET_MAKER",OrderRestrictions_COMPETING_MARKET_MAKER_get, OrderRestrictions_COMPETING_MARKET_MAKER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListExecInstType_WAIT_FOR_EXECUT_INSTRUCTION",ListExecInstType_WAIT_FOR_EXECUT_INSTRUCTION_get, ListExecInstType_WAIT_FOR_EXECUT_INSTRUCTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_SELL_DRIVEN",ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_SELL_DRIVEN_get, ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_SELL_DRIVEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListExecInstType_IMMED",ListExecInstType_IMMED_get, ListExecInstType_IMMED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListExecInstType_WAIT",ListExecInstType_WAIT_get, ListExecInstType_WAIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_BUY_DRIVEN_CASH_WITHDRAW",ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_BUY_DRIVEN_CASH_WITHDRAW_get, ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_BUY_DRIVEN_CASH_WITHDRAW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_3",ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_3_get, ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_3_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListExecInstType_IMMEDIATE",ListExecInstType_IMMEDIATE_get, ListExecInstType_IMMEDIATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_4",ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_4_get, ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_4_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_5",ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_5_get, ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_5_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_BUY_DRIVEN_CASH_TOP_UP",ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_BUY_DRIVEN_CASH_TOP_UP_get, ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_BUY_DRIVEN_CASH_TOP_UP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListExecInstType_EXCHCIVBUYTOP",ListExecInstType_EXCHCIVBUYTOP_get, ListExecInstType_EXCHCIVBUYTOP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListExecInstType_EXCHCIVBUYWD",ListExecInstType_EXCHCIVBUYWD_get, ListExecInstType_EXCHCIVBUYWD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListExecInstType_EXCHCIVSELL",ListExecInstType_EXCHCIVSELL_get, ListExecInstType_EXCHCIVSELL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListExecInstType_WAIT_FOR_EXECUTE_INSTRUCTION",ListExecInstType_WAIT_FOR_EXECUTE_INSTRUCTION_get, ListExecInstType_WAIT_FOR_EXECUTE_INSTRUCTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DistribPaymentMethod_FED_WIRE",DistribPaymentMethod_FED_WIRE_get, DistribPaymentMethod_FED_WIRE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DistribPaymentMethod_ACH_CREDIT",DistribPaymentMethod_ACH_CREDIT_get, DistribPaymentMethod_ACH_CREDIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DistribPaymentMethod_EUROCLEAR",DistribPaymentMethod_EUROCLEAR_get, DistribPaymentMethod_EUROCLEAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DistribPaymentMethod_TELEGRAPHICTRANSFER",DistribPaymentMethod_TELEGRAPHICTRANSFER_get, DistribPaymentMethod_TELEGRAPHICTRANSFER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DistribPaymentMethod_ACHCREDIT",DistribPaymentMethod_ACHCREDIT_get, DistribPaymentMethod_ACHCREDIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DistribPaymentMethod_TELEGRAPHIC_TRANSFER",DistribPaymentMethod_TELEGRAPHIC_TRANSFER_get, DistribPaymentMethod_TELEGRAPHIC_TRANSFER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DistribPaymentMethod_FEDWIRE",DistribPaymentMethod_FEDWIRE_get, DistribPaymentMethod_FEDWIRE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DistribPaymentMethod_CHEQUE",DistribPaymentMethod_CHEQUE_get, DistribPaymentMethod_CHEQUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DistribPaymentMethod_DIRECT_CREDIT",DistribPaymentMethod_DIRECT_CREDIT_get, DistribPaymentMethod_DIRECT_CREDIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DistribPaymentMethod_CREST",DistribPaymentMethod_CREST_get, DistribPaymentMethod_CREST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DistribPaymentMethod_BPAY",DistribPaymentMethod_BPAY_get, DistribPaymentMethod_BPAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DistribPaymentMethod_CLEARSTREAM",DistribPaymentMethod_CLEARSTREAM_get, DistribPaymentMethod_CLEARSTREAM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DistribPaymentMethod_DIRECTCREDITBECSBACS",DistribPaymentMethod_DIRECTCREDITBECSBACS_get, DistribPaymentMethod_DIRECTCREDITBECSBACS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DistribPaymentMethod_HIGHVALUECLEARINGSYSTEMHVACS",DistribPaymentMethod_HIGHVALUECLEARINGSYSTEMHVACS_get, DistribPaymentMethod_HIGHVALUECLEARINGSYSTEMHVACS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DistribPaymentMethod_NSCC",DistribPaymentMethod_NSCC_get, DistribPaymentMethod_NSCC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_HVACS",DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_HVACS_get, DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_HVACS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DistribPaymentMethod_REINVESTINFUND",DistribPaymentMethod_REINVESTINFUND_get, DistribPaymentMethod_REINVESTINFUND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DistribPaymentMethod_REINVEST_IN_FUND",DistribPaymentMethod_REINVEST_IN_FUND_get, DistribPaymentMethod_REINVEST_IN_FUND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderHandlingInstSource_NASD_OATS",OrderHandlingInstSource_NASD_OATS_get, OrderHandlingInstSource_NASD_OATS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AffirmStatus_CONFIRMREJECTED",AffirmStatus_CONFIRMREJECTED_get, AffirmStatus_CONFIRMREJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AffirmStatus_CONFIRM_REJECTED_IE_NOT_AFFIRMED",AffirmStatus_CONFIRM_REJECTED_IE_NOT_AFFIRMED_get, AffirmStatus_CONFIRM_REJECTED_IE_NOT_AFFIRMED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AffirmStatus_AFFIRMED",AffirmStatus_AFFIRMED_get, AffirmStatus_AFFIRMED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AffirmStatus_RECEIVED",AffirmStatus_RECEIVED_get, AffirmStatus_RECEIVED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrigCustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT",OrigCustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT_get, OrigCustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrigCustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT",OrigCustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT_get, OrigCustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrigCustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER",OrigCustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER_get, OrigCustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrigCustOrderCapacity_ALL_OTHER",OrigCustOrderCapacity_ALL_OTHER_get, OrigCustOrderCapacity_ALL_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocMethod_GUARANTOR",AllocMethod_GUARANTOR_get, AllocMethod_GUARANTOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocMethod_AUTOMATIC",AllocMethod_AUTOMATIC_get, AllocMethod_AUTOMATIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocMethod_MANUAL",AllocMethod_MANUAL_get, AllocMethod_MANUAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY",MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_get, MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CANCEL_ORDERS_FOR_ISSUER_OF_UNDERLYING_SECURITY",MassCancelResponse_CANCEL_ORDERS_FOR_ISSUER_OF_UNDERLYING_SECURITY_get, MassCancelResponse_CANCEL_ORDERS_FOR_ISSUER_OF_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_GROUP",MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_GROUP_get, MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_GROUP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CXLORDERSSECURITYTYPE",MassCancelResponse_CXLORDERSSECURITYTYPE_get, MassCancelResponse_CXLORDERSSECURITYTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CXLORDERSUNDERLYINGSECURITY",MassCancelResponse_CXLORDERSUNDERLYINGSECURITY_get, MassCancelResponse_CXLORDERSUNDERLYINGSECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CXLORDERSTRDSESSION",MassCancelResponse_CXLORDERSTRDSESSION_get, MassCancelResponse_CXLORDERSTRDSESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CXLALLORDERS",MassCancelResponse_CXLALLORDERS_get, MassCancelResponse_CXLALLORDERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET",MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_get, MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT",MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT_get, MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CXLREQREJ",MassCancelResponse_CXLREQREJ_get, MassCancelResponse_CXLREQREJ_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITYTYPE",MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITYTYPE_get, MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITYTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CANCEL_ORDERS_FOR_A_TRADING_SESSION",MassCancelResponse_CANCEL_ORDERS_FOR_A_TRADING_SESSION_get, MassCancelResponse_CANCEL_ORDERS_FOR_A_TRADING_SESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY",MassCancelResponse_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY_get, MassCancelResponse_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CXLORDERSSECURITY",MassCancelResponse_CXLORDERSSECURITY_get, MassCancelResponse_CXLORDERSSECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CXLORDERSPRODUCT",MassCancelResponse_CXLORDERSPRODUCT_get, MassCancelResponse_CXLORDERSPRODUCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CANCEL_ALL_ORDERS",MassCancelResponse_CANCEL_ALL_ORDERS_get, MassCancelResponse_CANCEL_ALL_ORDERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CANCEL_REQUEST_REJECTED",MassCancelResponse_CANCEL_REQUEST_REJECTED_get, MassCancelResponse_CANCEL_REQUEST_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITIES_ISSUER",MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITIES_ISSUER_get, MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITIES_ISSUER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CXLORDERSCFICODE",MassCancelResponse_CXLORDERSCFICODE_get, MassCancelResponse_CXLORDERSCFICODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CANCEL_ORDERS_FOR_A_CFICODE",MassCancelResponse_CANCEL_ORDERS_FOR_A_CFICODE_get, MassCancelResponse_CANCEL_ORDERS_FOR_A_CFICODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CANCEL_ORDERS_FOR_A_PRODUCT",MassCancelResponse_CANCEL_ORDERS_FOR_A_PRODUCT_get, MassCancelResponse_CANCEL_ORDERS_FOR_A_PRODUCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_NEW_CUSTOMER",StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_NEW_CUSTOMER_get, StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_NEW_CUSTOMER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_EXISTING_CUSTOMER",StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_EXISTING_CUSTOMER_get, StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_EXISTING_CUSTOMER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SymbolSfx_EUCP_WITH_LUMP_SUM_INTEREST_RATHER_THAN_DISCOUNT_PRICE",SymbolSfx_EUCP_WITH_LUMP_SUM_INTEREST_RATHER_THAN_DISCOUNT_PRICE_get, SymbolSfx_EUCP_WITH_LUMP_SUM_INTEREST_RATHER_THAN_DISCOUNT_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SymbolSfx_EUCPLUMPSUMINTEREST",SymbolSfx_EUCPLUMPSUMINTEREST_get, SymbolSfx_EUCPLUMPSUMINTEREST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SymbolSfx_WHENISSUED",SymbolSfx_WHENISSUED_get, SymbolSfx_WHENISSUED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SymbolSfx_WHEN_ISSUED_FOR_A_SECURITY_TO_BE_REISSUED_UNDER_AN_OLD_CUSIP_OR_ISIN",SymbolSfx_WHEN_ISSUED_FOR_A_SECURITY_TO_BE_REISSUED_UNDER_AN_OLD_CUSIP_OR_ISIN_get, SymbolSfx_WHEN_ISSUED_FOR_A_SECURITY_TO_BE_REISSUED_UNDER_AN_OLD_CUSIP_OR_ISIN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExDestinationIDSource_PROPRIETARY",ExDestinationIDSource_PROPRIETARY_get, ExDestinationIDSource_PROPRIETARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExDestinationIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER",ExDestinationIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER_get, ExDestinationIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExDestinationIDSource_BIC",ExDestinationIDSource_BIC_get, ExDestinationIDSource_BIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExDestinationIDSource_MIC",ExDestinationIDSource_MIC_get, ExDestinationIDSource_MIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExDestinationIDSource_ISO_COUNTRY_CODE",ExDestinationIDSource_ISO_COUNTRY_CODE_get, ExDestinationIDSource_ISO_COUNTRY_CODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityListRequestType_ALLSECURITIES",SecurityListRequestType_ALLSECURITIES_get, SecurityListRequestType_ALLSECURITIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityListRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID",SecurityListRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID_get, SecurityListRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityListRequestType_SECURITYTYPECFICODE",SecurityListRequestType_SECURITYTYPECFICODE_get, SecurityListRequestType_SECURITYTYPECFICODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityListRequestType_SYMBOL",SecurityListRequestType_SYMBOL_get, SecurityListRequestType_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityListRequestType_SECURITYTYPE_AND_OR_CFICODE",SecurityListRequestType_SECURITYTYPE_AND_OR_CFICODE_get, SecurityListRequestType_SECURITYTYPE_AND_OR_CFICODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityListRequestType_TRADINGSESSIONID",SecurityListRequestType_TRADINGSESSIONID_get, SecurityListRequestType_TRADINGSESSIONID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityListRequestType_ALL_SECURITIES",SecurityListRequestType_ALL_SECURITIES_get, SecurityListRequestType_ALL_SECURITIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityListRequestType_PRODUCT",SecurityListRequestType_PRODUCT_get, SecurityListRequestType_PRODUCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnReason_FORWARDCOLLATERALDEMAND",CollAsgnReason_FORWARDCOLLATERALDEMAND_get, CollAsgnReason_FORWARDCOLLATERALDEMAND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnReason_ADVERSETAXEVENT",CollAsgnReason_ADVERSETAXEVENT_get, CollAsgnReason_ADVERSETAXEVENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnReason_MARGINDEFICIENCY",CollAsgnReason_MARGINDEFICIENCY_get, CollAsgnReason_MARGINDEFICIENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnReason_TIME_WARNING",CollAsgnReason_TIME_WARNING_get, CollAsgnReason_TIME_WARNING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnReason_TIMEWARNING",CollAsgnReason_TIMEWARNING_get, CollAsgnReason_TIMEWARNING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnReason_ADVERSE_TAX_EVENT",CollAsgnReason_ADVERSE_TAX_EVENT_get, CollAsgnReason_ADVERSE_TAX_EVENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnReason_MARGINEXCESS",CollAsgnReason_MARGINEXCESS_get, CollAsgnReason_MARGINEXCESS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnReason_MARGIN_DEFICIENCY",CollAsgnReason_MARGIN_DEFICIENCY_get, CollAsgnReason_MARGIN_DEFICIENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnReason_SCHEDULED",CollAsgnReason_SCHEDULED_get, CollAsgnReason_SCHEDULED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnReason_INITIAL",CollAsgnReason_INITIAL_get, CollAsgnReason_INITIAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnReason_FORWARD_COLLATERAL_DEMAND",CollAsgnReason_FORWARD_COLLATERAL_DEMAND_get, CollAsgnReason_FORWARD_COLLATERAL_DEMAND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnReason_EVENTOFDEFAULT",CollAsgnReason_EVENTOFDEFAULT_get, CollAsgnReason_EVENTOFDEFAULT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnReason_MARGIN_EXCESS",CollAsgnReason_MARGIN_EXCESS_get, CollAsgnReason_MARGIN_EXCESS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnReason_EVENT_OF_DEFAULT",CollAsgnReason_EVENT_OF_DEFAULT_get, CollAsgnReason_EVENT_OF_DEFAULT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlPriceType_FINAL",SettlPriceType_FINAL_get, SettlPriceType_FINAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlPriceType_THEORETICAL",SettlPriceType_THEORETICAL_get, SettlPriceType_THEORETICAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DealingCapacity_RISKLESS_PRINCIPAL",DealingCapacity_RISKLESS_PRINCIPAL_get, DealingCapacity_RISKLESS_PRINCIPAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DealingCapacity_PRINCIPAL",DealingCapacity_PRINCIPAL_get, DealingCapacity_PRINCIPAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DealingCapacity_AGENT",DealingCapacity_AGENT_get, DealingCapacity_AGENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RateSourceType_SECONDARY",RateSourceType_SECONDARY_get, RateSourceType_SECONDARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RateSourceType_PRIMARY",RateSourceType_PRIMARY_get, RateSourceType_PRIMARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AggregatedBook_NO",AggregatedBook_NO_get, AggregatedBook_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AggregatedBook_YES",AggregatedBook_YES_get, AggregatedBook_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosQtyStatus_SUBMITTED",PosQtyStatus_SUBMITTED_get, PosQtyStatus_SUBMITTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosQtyStatus_REJECTED",PosQtyStatus_REJECTED_get, PosQtyStatus_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosQtyStatus_ACCEPTED",PosQtyStatus_ACCEPTED_get, PosQtyStatus_ACCEPTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_TradingSessionStatusRequest",MsgType_TradingSessionStatusRequest_get, MsgType_TradingSessionStatusRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_ListStatus",MsgType_ListStatus_get, MsgType_ListStatus_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_Email",MsgType_Email_get, MsgType_Email_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_ListExecute",MsgType_ListExecute_get, MsgType_ListExecute_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_Confirmation",MsgType_Confirmation_get, MsgType_Confirmation_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_NewOrderMultileg",MsgType_NewOrderMultileg_get, MsgType_NewOrderMultileg_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_IndicationofInterest",MsgType_IndicationofInterest_get, MsgType_IndicationofInterest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_MarketDataIncrementalRefresh",MsgType_MarketDataIncrementalRefresh_get, MsgType_MarketDataIncrementalRefresh_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_TradeCaptureReport",MsgType_TradeCaptureReport_get, MsgType_TradeCaptureReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_RequestForPositionsAck",MsgType_RequestForPositionsAck_get, MsgType_RequestForPositionsAck_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_StreamAssignmentRequest",MsgType_StreamAssignmentRequest_get, MsgType_StreamAssignmentRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_SecurityListRequest",MsgType_SecurityListRequest_get, MsgType_SecurityListRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_CollateralReport",MsgType_CollateralReport_get, MsgType_CollateralReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_PositionMaintenanceReport",MsgType_PositionMaintenanceReport_get, MsgType_PositionMaintenanceReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_PositionReport",MsgType_PositionReport_get, MsgType_PositionReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_StreamAssignmentReportACK",MsgType_StreamAssignmentReportACK_get, MsgType_StreamAssignmentReportACK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_UserRequest",MsgType_UserRequest_get, MsgType_UserRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_PositionMaintenanceRequest",MsgType_PositionMaintenanceRequest_get, MsgType_PositionMaintenanceRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_NetworkCounterpartySystemStatusResponse",MsgType_NetworkCounterpartySystemStatusResponse_get, MsgType_NetworkCounterpartySystemStatusResponse_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_NewOrderCross",MsgType_NewOrderCross_get, MsgType_NewOrderCross_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_AdjustedPositionReport",MsgType_AdjustedPositionReport_get, MsgType_AdjustedPositionReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_Logon",MsgType_Logon_get, MsgType_Logon_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_IOI",MsgType_IOI_get, MsgType_IOI_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_ListStrikePrice",MsgType_ListStrikePrice_get, MsgType_ListStrikePrice_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_BidRequest",MsgType_BidRequest_get, MsgType_BidRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_TradingSessionStatus",MsgType_TradingSessionStatus_get, MsgType_TradingSessionStatus_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_RegistrationInstructionsResponse",MsgType_RegistrationInstructionsResponse_get, MsgType_RegistrationInstructionsResponse_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_Advertisement",MsgType_Advertisement_get, MsgType_Advertisement_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_MassQuote",MsgType_MassQuote_get, MsgType_MassQuote_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_Logout",MsgType_Logout_get, MsgType_Logout_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_AllocationReport",MsgType_AllocationReport_get, MsgType_AllocationReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_SecurityDefinitionUpdateReport",MsgType_SecurityDefinitionUpdateReport_get, MsgType_SecurityDefinitionUpdateReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_ListStatusRequest",MsgType_ListStatusRequest_get, MsgType_ListStatusRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_BusinessMessageReject",MsgType_BusinessMessageReject_get, MsgType_BusinessMessageReject_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_ConfirmationAck",MsgType_ConfirmationAck_get, MsgType_ConfirmationAck_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_TestRequest",MsgType_TestRequest_get, MsgType_TestRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_SecurityList",MsgType_SecurityList_get, MsgType_SecurityList_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_ListCancelRequest",MsgType_ListCancelRequest_get, MsgType_ListCancelRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_News",MsgType_News_get, MsgType_News_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_TradingSessionListUpdateReport",MsgType_TradingSessionListUpdateReport_get, MsgType_TradingSessionListUpdateReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_Heartbeat",MsgType_Heartbeat_get, MsgType_Heartbeat_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_QuoteAcknowledgement",MsgType_QuoteAcknowledgement_get, MsgType_QuoteAcknowledgement_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_AllocationReportAck",MsgType_AllocationReportAck_get, MsgType_AllocationReportAck_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_ConfirmationRequest",MsgType_ConfirmationRequest_get, MsgType_ConfirmationRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_OrderMassActionReport",MsgType_OrderMassActionReport_get, MsgType_OrderMassActionReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_CollateralInquiry",MsgType_CollateralInquiry_get, MsgType_CollateralInquiry_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_SecurityTypeRequest",MsgType_SecurityTypeRequest_get, MsgType_SecurityTypeRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_NewOrderList",MsgType_NewOrderList_get, MsgType_NewOrderList_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_ExecutionAcknowledgement",MsgType_ExecutionAcknowledgement_get, MsgType_ExecutionAcknowledgement_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_TradingSessionListRequest",MsgType_TradingSessionListRequest_get, MsgType_TradingSessionListRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_SecurityTypes",MsgType_SecurityTypes_get, MsgType_SecurityTypes_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_MarketDefinition",MsgType_MarketDefinition_get, MsgType_MarketDefinition_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_SequenceReset",MsgType_SequenceReset_get, MsgType_SequenceReset_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_CollateralResponse",MsgType_CollateralResponse_get, MsgType_CollateralResponse_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_MassQuoteAcknowledgement",MsgType_MassQuoteAcknowledgement_get, MsgType_MassQuoteAcknowledgement_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_QuoteResponse",MsgType_QuoteResponse_get, MsgType_QuoteResponse_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_QuoteStatusRequest",MsgType_QuoteStatusRequest_get, MsgType_QuoteStatusRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_QuoteCancel",MsgType_QuoteCancel_get, MsgType_QuoteCancel_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_ContraryIntentionReport",MsgType_ContraryIntentionReport_get, MsgType_ContraryIntentionReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_PartyDetailsListReport",MsgType_PartyDetailsListReport_get, MsgType_PartyDetailsListReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_PartyDetailsListRequest",MsgType_PartyDetailsListRequest_get, MsgType_PartyDetailsListRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_CrossOrderCancelRequest",MsgType_CrossOrderCancelRequest_get, MsgType_CrossOrderCancelRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_NewOrderSingle",MsgType_NewOrderSingle_get, MsgType_NewOrderSingle_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_DerivativeSecurityListRequest",MsgType_DerivativeSecurityListRequest_get, MsgType_DerivativeSecurityListRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_CollateralRequest",MsgType_CollateralRequest_get, MsgType_CollateralRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_UserNotification",MsgType_UserNotification_get, MsgType_UserNotification_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_UserResponse",MsgType_UserResponse_get, MsgType_UserResponse_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_DontKnowTrade",MsgType_DontKnowTrade_get, MsgType_DontKnowTrade_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_TradeCaptureReportAck",MsgType_TradeCaptureReportAck_get, MsgType_TradeCaptureReportAck_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_ApplicationMessageRequest",MsgType_ApplicationMessageRequest_get, MsgType_ApplicationMessageRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_MultilegOrderCancelReplace",MsgType_MultilegOrderCancelReplace_get, MsgType_MultilegOrderCancelReplace_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_OrderCancelReject",MsgType_OrderCancelReject_get, MsgType_OrderCancelReject_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_ExecutionReport",MsgType_ExecutionReport_get, MsgType_ExecutionReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_QuoteStatusReport",MsgType_QuoteStatusReport_get, MsgType_QuoteStatusReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_ResendRequest",MsgType_ResendRequest_get, MsgType_ResendRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_Quote",MsgType_Quote_get, MsgType_Quote_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_SettlementInstructionRequest",MsgType_SettlementInstructionRequest_get, MsgType_SettlementInstructionRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_SecurityListUpdateReport",MsgType_SecurityListUpdateReport_get, MsgType_SecurityListUpdateReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_AllocationInstructionAlert",MsgType_AllocationInstructionAlert_get, MsgType_AllocationInstructionAlert_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_TradeCaptureReportRequestAck",MsgType_TradeCaptureReportRequestAck_get, MsgType_TradeCaptureReportRequestAck_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_AllocationInstruction",MsgType_AllocationInstruction_get, MsgType_AllocationInstruction_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_Allocation",MsgType_Allocation_get, MsgType_Allocation_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_ApplicationMessageReport",MsgType_ApplicationMessageReport_get, MsgType_ApplicationMessageReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_RegistrationInstructions",MsgType_RegistrationInstructions_get, MsgType_RegistrationInstructions_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_SecurityDefinition",MsgType_SecurityDefinition_get, MsgType_SecurityDefinition_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_SecurityDefinitionRequest",MsgType_SecurityDefinitionRequest_get, MsgType_SecurityDefinitionRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_SecurityStatus",MsgType_SecurityStatus_get, MsgType_SecurityStatus_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_DerivativeSecurityList",MsgType_DerivativeSecurityList_get, MsgType_DerivativeSecurityList_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_NetworkCounterpartySystemStatusRequest",MsgType_NetworkCounterpartySystemStatusRequest_get, MsgType_NetworkCounterpartySystemStatusRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_MarketDefinitionRequest",MsgType_MarketDefinitionRequest_get, MsgType_MarketDefinitionRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_Reject",MsgType_Reject_get, MsgType_Reject_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_DerivativeSecurityListUpdateReport",MsgType_DerivativeSecurityListUpdateReport_get, MsgType_DerivativeSecurityListUpdateReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_QuoteRequestReject",MsgType_QuoteRequestReject_get, MsgType_QuoteRequestReject_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_OrderMassStatusRequest",MsgType_OrderMassStatusRequest_get, MsgType_OrderMassStatusRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_ApplicationMessageRequestAck",MsgType_ApplicationMessageRequestAck_get, MsgType_ApplicationMessageRequestAck_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_SecurityStatusRequest",MsgType_SecurityStatusRequest_get, MsgType_SecurityStatusRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_AllocationACK",MsgType_AllocationACK_get, MsgType_AllocationACK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_MarketDefinitionUpdateReport",MsgType_MarketDefinitionUpdateReport_get, MsgType_MarketDefinitionUpdateReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_CrossOrderCancelReplaceRequest",MsgType_CrossOrderCancelReplaceRequest_get, MsgType_CrossOrderCancelReplaceRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_OrderMassCancelReport",MsgType_OrderMassCancelReport_get, MsgType_OrderMassCancelReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_AssignmentReport",MsgType_AssignmentReport_get, MsgType_AssignmentReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_BidResponse",MsgType_BidResponse_get, MsgType_BidResponse_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_RequestForPositions",MsgType_RequestForPositions_get, MsgType_RequestForPositions_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_SettlementObligationReport",MsgType_SettlementObligationReport_get, MsgType_SettlementObligationReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_OrderMassCancelRequest",MsgType_OrderMassCancelRequest_get, MsgType_OrderMassCancelRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_TradingSessionList",MsgType_TradingSessionList_get, MsgType_TradingSessionList_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_OrderStatusRequest",MsgType_OrderStatusRequest_get, MsgType_OrderStatusRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_CollateralAssignment",MsgType_CollateralAssignment_get, MsgType_CollateralAssignment_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_StreamAssignmentReport",MsgType_StreamAssignmentReport_get, MsgType_StreamAssignmentReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_OrderMassActionRequest",MsgType_OrderMassActionRequest_get, MsgType_OrderMassActionRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_AllocationAck",MsgType_AllocationAck_get, MsgType_AllocationAck_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_QuoteRequest",MsgType_QuoteRequest_get, MsgType_QuoteRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_CollateralInquiryAck",MsgType_CollateralInquiryAck_get, MsgType_CollateralInquiryAck_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_MarketDataSnapshotFullRefresh",MsgType_MarketDataSnapshotFullRefresh_get, MsgType_MarketDataSnapshotFullRefresh_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_SettlementInstructions",MsgType_SettlementInstructions_get, MsgType_SettlementInstructions_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_OrderCancelReplaceRequest",MsgType_OrderCancelReplaceRequest_get, MsgType_OrderCancelReplaceRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_TradeCaptureReportRequest",MsgType_TradeCaptureReportRequest_get, MsgType_TradeCaptureReportRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_RFQRequest",MsgType_RFQRequest_get, MsgType_RFQRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_OrderCancelRequest",MsgType_OrderCancelRequest_get, MsgType_OrderCancelRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_MultilegOrderCancelReplaceRequest",MsgType_MultilegOrderCancelReplaceRequest_get, MsgType_MultilegOrderCancelReplaceRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_AllocationInstructionAck",MsgType_AllocationInstructionAck_get, MsgType_AllocationInstructionAck_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_MarketDataRequest",MsgType_MarketDataRequest_get, MsgType_MarketDataRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_MarketDataRequestReject",MsgType_MarketDataRequestReject_get, MsgType_MarketDataRequestReject_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultiLegReportingType_SINGLE",MultiLegReportingType_SINGLE_get, MultiLegReportingType_SINGLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultiLegReportingType_MULTILEG",MultiLegReportingType_MULTILEG_get, MultiLegReportingType_MULTILEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultiLegReportingType_SINGLE_SECURITY",MultiLegReportingType_SINGLE_SECURITY_get, MultiLegReportingType_SINGLE_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultiLegReportingType_MULTI_LEG_SECURITY",MultiLegReportingType_MULTI_LEG_SECURITY_get, MultiLegReportingType_MULTI_LEG_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultiLegReportingType_INDIVLEG",MultiLegReportingType_INDIVLEG_get, MultiLegReportingType_INDIVLEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY",MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY_get, MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY",MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY_get, MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IDSource_EXCHANGE_SYMBOL",IDSource_EXCHANGE_SYMBOL_get, IDSource_EXCHANGE_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IDSource_RIC_CODE",IDSource_RIC_CODE_get, IDSource_RIC_CODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IDSource_ISO_CURRENCY_CODE",IDSource_ISO_CURRENCY_CODE_get, IDSource_ISO_CURRENCY_CODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IDSource_ISIN_NUMBER",IDSource_ISIN_NUMBER_get, IDSource_ISIN_NUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IDSource_SEDOL",IDSource_SEDOL_get, IDSource_SEDOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IDSource_ISO_COUNTRY_CODE",IDSource_ISO_COUNTRY_CODE_get, IDSource_ISO_COUNTRY_CODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IDSource_CONSOLIDATED_TAPE_ASSOCIATION",IDSource_CONSOLIDATED_TAPE_ASSOCIATION_get, IDSource_CONSOLIDATED_TAPE_ASSOCIATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IDSource_QUIK",IDSource_QUIK_get, IDSource_QUIK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IDSource_CUSIP",IDSource_CUSIP_get, IDSource_CUSIP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_NEW",OrdStatus_NEW_get, OrdStatus_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_CALCULATED",OrdStatus_CALCULATED_get, OrdStatus_CALCULATED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_PENDINGNEW",OrdStatus_PENDINGNEW_get, OrdStatus_PENDINGNEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_PENDING_CANCEL",OrdStatus_PENDING_CANCEL_get, OrdStatus_PENDING_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_PARTIAL",OrdStatus_PARTIAL_get, OrdStatus_PARTIAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_PENDING_CANCEL_REPLACE",OrdStatus_PENDING_CANCEL_REPLACE_get, OrdStatus_PENDING_CANCEL_REPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_PENDING_NEW",OrdStatus_PENDING_NEW_get, OrdStatus_PENDING_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_STOPPED",OrdStatus_STOPPED_get, OrdStatus_STOPPED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_FILLED",OrdStatus_FILLED_get, OrdStatus_FILLED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_PENDING_REPLACE",OrdStatus_PENDING_REPLACE_get, OrdStatus_PENDING_REPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_CANCELED",OrdStatus_CANCELED_get, OrdStatus_CANCELED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_ACCEPTED_FOR_BIDDING",OrdStatus_ACCEPTED_FOR_BIDDING_get, OrdStatus_ACCEPTED_FOR_BIDDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_SUSPENDED",OrdStatus_SUSPENDED_get, OrdStatus_SUSPENDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_DONE",OrdStatus_DONE_get, OrdStatus_DONE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_REJECTED",OrdStatus_REJECTED_get, OrdStatus_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_PARTIALLY_FILLED",OrdStatus_PARTIALLY_FILLED_get, OrdStatus_PARTIALLY_FILLED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_EXPIRED",OrdStatus_EXPIRED_get, OrdStatus_EXPIRED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_REPLACED",OrdStatus_REPLACED_get, OrdStatus_REPLACED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_DONE_FOR_DAY",OrdStatus_DONE_FOR_DAY_get, OrdStatus_DONE_FOR_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_ACCEPTBIDDING",OrdStatus_ACCEPTBIDDING_get, OrdStatus_ACCEPTBIDDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_PENDINGREP",OrdStatus_PENDINGREP_get, OrdStatus_PENDINGREP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustomerOrFirm_FIRM",CustomerOrFirm_FIRM_get, CustomerOrFirm_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustomerOrFirm_CUSTOMER",CustomerOrFirm_CUSTOMER_get, CustomerOrFirm_CUSTOMER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AdjustmentType_DELTA_MINUS",AdjustmentType_DELTA_MINUS_get, AdjustmentType_DELTA_MINUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AdjustmentType_DELTAPLUS",AdjustmentType_DELTAPLUS_get, AdjustmentType_DELTAPLUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AdjustmentType_DELTA_PLUS",AdjustmentType_DELTA_PLUS_get, AdjustmentType_DELTA_PLUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AdjustmentType_DELTAMINUS",AdjustmentType_DELTAMINUS_get, AdjustmentType_DELTAMINUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AdjustmentType_FINAL",AdjustmentType_FINAL_get, AdjustmentType_FINAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AdjustmentType_PROCESSREQUESTASMARGINDISPOSITION",AdjustmentType_PROCESSREQUESTASMARGINDISPOSITION_get, AdjustmentType_PROCESSREQUESTASMARGINDISPOSITION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AdjustmentType_PROCESS_REQUEST_AS_MARGIN_DISPOSITION",AdjustmentType_PROCESS_REQUEST_AS_MARGIN_DISPOSITION_get, AdjustmentType_PROCESS_REQUEST_AS_MARGIN_DISPOSITION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AsOfIndicator_TRUE",AsOfIndicator_TRUE_get, AsOfIndicator_TRUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AsOfIndicator_FALSE",AsOfIndicator_FALSE_get, AsOfIndicator_FALSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionScope_ALL_ORDERS_FOR_A_MARKET_SEGMENT",MassActionScope_ALL_ORDERS_FOR_A_MARKET_SEGMENT_get, MassActionScope_ALL_ORDERS_FOR_A_MARKET_SEGMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionScope_ALL_ORDERS_FOR_A_MARKET",MassActionScope_ALL_ORDERS_FOR_A_MARKET_get, MassActionScope_ALL_ORDERS_FOR_A_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionScope_ALL_ORDERS_FOR_AN_UNDERLYING_SECURITY",MassActionScope_ALL_ORDERS_FOR_AN_UNDERLYING_SECURITY_get, MassActionScope_ALL_ORDERS_FOR_AN_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionScope_ALL_ORDERS",MassActionScope_ALL_ORDERS_get, MassActionScope_ALL_ORDERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionScope_ALL_ORDERS_FOR_A_CFICODE",MassActionScope_ALL_ORDERS_FOR_A_CFICODE_get, MassActionScope_ALL_ORDERS_FOR_A_CFICODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionScope_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY",MassActionScope_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_get, MassActionScope_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionScope_ALL_ORDERS_FOR_A_SECURITY",MassActionScope_ALL_ORDERS_FOR_A_SECURITY_get, MassActionScope_ALL_ORDERS_FOR_A_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionScope_ALL_ORDERS_FOR_A_TRADING_SESSION",MassActionScope_ALL_ORDERS_FOR_A_TRADING_SESSION_get, MassActionScope_ALL_ORDERS_FOR_A_TRADING_SESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionScope_CANCEL_FOR_SECURITY_ISSUER",MassActionScope_CANCEL_FOR_SECURITY_ISSUER_get, MassActionScope_CANCEL_FOR_SECURITY_ISSUER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionScope_ALL_ORDERS_FOR_A_SECURITY_GROUP",MassActionScope_ALL_ORDERS_FOR_A_SECURITY_GROUP_get, MassActionScope_ALL_ORDERS_FOR_A_SECURITY_GROUP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionScope_ALL_ORDERS_FOR_A_PRODUCT",MassActionScope_ALL_ORDERS_FOR_A_PRODUCT_get, MassActionScope_ALL_ORDERS_FOR_A_PRODUCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionScope_ALL_ORDERS_FOR_A_SECURITYTYPE",MassActionScope_ALL_ORDERS_FOR_A_SECURITYTYPE_get, MassActionScope_ALL_ORDERS_FOR_A_SECURITYTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"VenueType_PIT",VenueType_PIT_get, VenueType_PIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"VenueType_EX_PIT",VenueType_EX_PIT_get, VenueType_EX_PIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"VenueType_ELECTRONIC",VenueType_ELECTRONIC_get, VenueType_ELECTRONIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionType_CANCEL_ORDERS",MassActionType_CANCEL_ORDERS_get, MassActionType_CANCEL_ORDERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionType_RELEASE_ORDERS_FROM_SUSPENSION",MassActionType_RELEASE_ORDERS_FROM_SUSPENSION_get, MassActionType_RELEASE_ORDERS_FROM_SUSPENSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionType_SUSPEND_ORDERS",MassActionType_SUSPEND_ORDERS_get, MassActionType_SUSPEND_ORDERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosMaintResult_SUCCESSFULCOMPLETION",PosMaintResult_SUCCESSFULCOMPLETION_get, PosMaintResult_SUCCESSFULCOMPLETION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosMaintResult_SUCCESSFUL_COMPLETION",PosMaintResult_SUCCESSFUL_COMPLETION_get, PosMaintResult_SUCCESSFUL_COMPLETION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosMaintResult_OTHER",PosMaintResult_OTHER_get, PosMaintResult_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosMaintResult_REJECTED",PosMaintResult_REJECTED_get, PosMaintResult_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIShares_MEDIUM",IOIShares_MEDIUM_get, IOIShares_MEDIUM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIShares_LARGE",IOIShares_LARGE_get, IOIShares_LARGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIShares_SMALL",IOIShares_SMALL_get, IOIShares_SMALL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegOffsetType_PRICE",PegOffsetType_PRICE_get, PegOffsetType_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegOffsetType_BASISPOINTS",PegOffsetType_BASISPOINTS_get, PegOffsetType_BASISPOINTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegOffsetType_PRICE_TIER",PegOffsetType_PRICE_TIER_get, PegOffsetType_PRICE_TIER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegOffsetType_TICKS",PegOffsetType_TICKS_get, PegOffsetType_TICKS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegOffsetType_PRICETIERLEVEL",PegOffsetType_PRICETIERLEVEL_get, PegOffsetType_PRICETIERLEVEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegOffsetType_BASIS_POINTS",PegOffsetType_BASIS_POINTS_get, PegOffsetType_BASIS_POINTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_INVALID_OR_UNKOWN_MARKET_SEGMENT",MassCancelRejectReason_INVALID_OR_UNKOWN_MARKET_SEGMENT_get, MassCancelRejectReason_INVALID_OR_UNKOWN_MARKET_SEGMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY",MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_get, MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_INVALIDSECURITY",MassCancelRejectReason_INVALIDSECURITY_get, MassCancelRejectReason_INVALIDSECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_MASS_CANCEL_NOT_SUPPORTED",MassCancelRejectReason_MASS_CANCEL_NOT_SUPPORTED_get, MassCancelRejectReason_MASS_CANCEL_NOT_SUPPORTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP",MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP_get, MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_INVALID_OR_UNKOWN_UNDERLYING_SECURITY",MassCancelRejectReason_INVALID_OR_UNKOWN_UNDERLYING_SECURITY_get, MassCancelRejectReason_INVALID_OR_UNKOWN_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_INVALIDPRODUCT",MassCancelRejectReason_INVALIDPRODUCT_get, MassCancelRejectReason_INVALIDPRODUCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY",MassCancelRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_get, MassCancelRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE",MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE_get, MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_INVALID_OR_UNKNOWN_CFICODE",MassCancelRejectReason_INVALID_OR_UNKNOWN_CFICODE_get, MassCancelRejectReason_INVALID_OR_UNKNOWN_CFICODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION",MassCancelRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION_get, MassCancelRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_INVALID_OR_UNKNOWN_MARKET",MassCancelRejectReason_INVALID_OR_UNKNOWN_MARKET_get, MassCancelRejectReason_INVALID_OR_UNKNOWN_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_TYPE",MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_TYPE_get, MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_INVALIDUNDERLYING",MassCancelRejectReason_INVALIDUNDERLYING_get, MassCancelRejectReason_INVALIDUNDERLYING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_OTHER",MassCancelRejectReason_OTHER_get, MassCancelRejectReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER",MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_get, MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_INVALIDCFICODE",MassCancelRejectReason_INVALIDCFICODE_get, MassCancelRejectReason_INVALIDCFICODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_INVALIDSECURITYTYPE",MassCancelRejectReason_INVALIDSECURITYTYPE_get, MassCancelRejectReason_INVALIDSECURITYTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_INVALID_OR_UNKNOWN_PRODUCT",MassCancelRejectReason_INVALID_OR_UNKNOWN_PRODUCT_get, MassCancelRejectReason_INVALID_OR_UNKNOWN_PRODUCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_INVALID_OR_UNKNOWN_UNDERLYING",MassCancelRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_get, MassCancelRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_INVALIDTRDSESSION",MassCancelRejectReason_INVALIDTRDSESSION_get, MassCancelRejectReason_INVALIDTRDSESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_MASSCXLNOTSUPPORTED",MassCancelRejectReason_MASSCXLNOTSUPPORTED_get, MassCancelRejectReason_MASSCXLNOTSUPPORTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ResponseTransportType_OUTOFBAND",ResponseTransportType_OUTOFBAND_get, ResponseTransportType_OUTOFBAND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ResponseTransportType_INBAND",ResponseTransportType_INBAND_get, ResponseTransportType_INBAND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ResponseTransportType_OUT_OF_BAND",ResponseTransportType_OUT_OF_BAND_get, ResponseTransportType_OUT_OF_BAND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesStatusRejReason_UNKNOWN_OR_INVALID_TRADINGSESSIONID",TradSesStatusRejReason_UNKNOWN_OR_INVALID_TRADINGSESSIONID_get, TradSesStatusRejReason_UNKNOWN_OR_INVALID_TRADINGSESSIONID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesStatusRejReason_UNKNOWNTRADINGSESSIONID",TradSesStatusRejReason_UNKNOWNTRADINGSESSIONID_get, TradSesStatusRejReason_UNKNOWNTRADINGSESSIONID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesStatusRejReason_OTHER",TradSesStatusRejReason_OTHER_get, TradSesStatusRejReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdRegTimestampType_EXECUTION_TIME",TrdRegTimestampType_EXECUTION_TIME_get, TrdRegTimestampType_EXECUTION_TIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdRegTimestampType_BROKEREXECUTION",TrdRegTimestampType_BROKEREXECUTION_get, TrdRegTimestampType_BROKEREXECUTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdRegTimestampType_BROKERRECEIPT",TrdRegTimestampType_BROKERRECEIPT_get, TrdRegTimestampType_BROKERRECEIPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdRegTimestampType_TIMEIN",TrdRegTimestampType_TIMEIN_get, TrdRegTimestampType_TIMEIN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdRegTimestampType_TIME_IN",TrdRegTimestampType_TIME_IN_get, TrdRegTimestampType_TIME_IN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdRegTimestampType_TIMEOUT",TrdRegTimestampType_TIMEOUT_get, TrdRegTimestampType_TIMEOUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdRegTimestampType_SUBMISSION_TO_CLEARING",TrdRegTimestampType_SUBMISSION_TO_CLEARING_get, TrdRegTimestampType_SUBMISSION_TO_CLEARING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdRegTimestampType_BROKER_RECEIPT",TrdRegTimestampType_BROKER_RECEIPT_get, TrdRegTimestampType_BROKER_RECEIPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdRegTimestampType_DESK_RECEIPT",TrdRegTimestampType_DESK_RECEIPT_get, TrdRegTimestampType_DESK_RECEIPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdRegTimestampType_EXECUTIONTIME",TrdRegTimestampType_EXECUTIONTIME_get, TrdRegTimestampType_EXECUTIONTIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdRegTimestampType_BROKER_EXECUTION",TrdRegTimestampType_BROKER_EXECUTION_get, TrdRegTimestampType_BROKER_EXECUTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdRegTimestampType_TIME_OUT",TrdRegTimestampType_TIME_OUT_get, TrdRegTimestampType_TIME_OUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplVerID_FIX50SP1",ApplVerID_FIX50SP1_get, ApplVerID_FIX50SP1_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplVerID_FIX27",ApplVerID_FIX27_get, ApplVerID_FIX27_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplVerID_FIX50SP2",ApplVerID_FIX50SP2_get, ApplVerID_FIX50SP2_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplVerID_FIX50",ApplVerID_FIX50_get, ApplVerID_FIX50_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplVerID_FIX40",ApplVerID_FIX40_get, ApplVerID_FIX40_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplVerID_FIX41",ApplVerID_FIX41_get, ApplVerID_FIX41_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplVerID_FIX30",ApplVerID_FIX30_get, ApplVerID_FIX30_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplVerID_FIX42",ApplVerID_FIX42_get, ApplVerID_FIX42_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplVerID_FIX43",ApplVerID_FIX43_get, ApplVerID_FIX43_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplVerID_FIX44",ApplVerID_FIX44_get, ApplVerID_FIX44_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HandlInst_MANUAL_ORDER_BEST_EXECUTION",HandlInst_MANUAL_ORDER_BEST_EXECUTION_get, HandlInst_MANUAL_ORDER_BEST_EXECUTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HandlInst_AUTOEXECPUB",HandlInst_AUTOEXECPUB_get, HandlInst_AUTOEXECPUB_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HandlInst_AUTOMATED_EXECUTION_ORDER_PRIVATE_NO_BROKER_INTERVENTION",HandlInst_AUTOMATED_EXECUTION_ORDER_PRIVATE_NO_BROKER_INTERVENTION_get, HandlInst_AUTOMATED_EXECUTION_ORDER_PRIVATE_NO_BROKER_INTERVENTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HandlInst_AUTOEXECPRIV",HandlInst_AUTOEXECPRIV_get, HandlInst_AUTOEXECPRIV_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HandlInst_AUTOMATED_EXECUTION_ORDER_PUBLIC_BROKER_INTERVENTION_OK",HandlInst_AUTOMATED_EXECUTION_ORDER_PUBLIC_BROKER_INTERVENTION_OK_get, HandlInst_AUTOMATED_EXECUTION_ORDER_PUBLIC_BROKER_INTERVENTION_OK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HandlInst_MANUAL",HandlInst_MANUAL_get, HandlInst_MANUAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradingSessionSubID_POST_TRADING",TradingSessionSubID_POST_TRADING_get, TradingSessionSubID_POST_TRADING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradingSessionSubID_INTRADAY_AUCTION",TradingSessionSubID_INTRADAY_AUCTION_get, TradingSessionSubID_INTRADAY_AUCTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradingSessionSubID_PRE_TRADING",TradingSessionSubID_PRE_TRADING_get, TradingSessionSubID_PRE_TRADING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradingSessionSubID_QUIESCENT",TradingSessionSubID_QUIESCENT_get, TradingSessionSubID_QUIESCENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradingSessionSubID_3",TradingSessionSubID_3_get, TradingSessionSubID_3_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradingSessionSubID_OPENING_OR_OPENING_AUCTION",TradingSessionSubID_OPENING_OR_OPENING_AUCTION_get, TradingSessionSubID_OPENING_OR_OPENING_AUCTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradingSessionSubID_CLOSING_OR_CLOSING_AUCTION",TradingSessionSubID_CLOSING_OR_CLOSING_AUCTION_get, TradingSessionSubID_CLOSING_OR_CLOSING_AUCTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_SWAP_VALUE_FACTOR",MDEntryType_SWAP_VALUE_FACTOR_get, MDEntryType_SWAP_VALUE_FACTOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_OPEN_INTEREST",MDEntryType_OPEN_INTEREST_get, MDEntryType_OPEN_INTEREST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_COMPOSITE_UNDERLYING_PRICE",MDEntryType_COMPOSITE_UNDERLYING_PRICE_get, MDEntryType_COMPOSITE_UNDERLYING_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_SESSION_HIGH_BID",MDEntryType_SESSION_HIGH_BID_get, MDEntryType_SESSION_HIGH_BID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_INDEXVALUE",MDEntryType_INDEXVALUE_get, MDEntryType_INDEXVALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_OPENINTEREST",MDEntryType_OPENINTEREST_get, MDEntryType_OPENINTEREST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_CLOSING_PRICE",MDEntryType_CLOSING_PRICE_get, MDEntryType_CLOSING_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_PRIOR_SETTLE_PRICE",MDEntryType_PRIOR_SETTLE_PRICE_get, MDEntryType_PRIOR_SETTLE_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_TRADING_SESSION_VWAP_PRICE",MDEntryType_TRADING_SESSION_VWAP_PRICE_get, MDEntryType_TRADING_SESSION_VWAP_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_TRADING_SESSION_LOW_PRICE",MDEntryType_TRADING_SESSION_LOW_PRICE_get, MDEntryType_TRADING_SESSION_LOW_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_SETTLE_HIGH_PRICE",MDEntryType_SETTLE_HIGH_PRICE_get, MDEntryType_SETTLE_HIGH_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_IMBALANCE",MDEntryType_IMBALANCE_get, MDEntryType_IMBALANCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_FIXING_PRICE",MDEntryType_FIXING_PRICE_get, MDEntryType_FIXING_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_CASH_RATE",MDEntryType_CASH_RATE_get, MDEntryType_CASH_RATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_CLOSING",MDEntryType_CLOSING_get, MDEntryType_CLOSING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_OPENING",MDEntryType_OPENING_get, MDEntryType_OPENING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_OPENING_PRICE",MDEntryType_OPENING_PRICE_get, MDEntryType_OPENING_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_TRADINGHIGH",MDEntryType_TRADINGHIGH_get, MDEntryType_TRADINGHIGH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_TRADEVOLUME",MDEntryType_TRADEVOLUME_get, MDEntryType_TRADEVOLUME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_TRADE",MDEntryType_TRADE_get, MDEntryType_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS",MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS_get, MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_SIMULATED_SELL_PRICE",MDEntryType_SIMULATED_SELL_PRICE_get, MDEntryType_SIMULATED_SELL_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_EMPTY_BOOK",MDEntryType_EMPTY_BOOK_get, MDEntryType_EMPTY_BOOK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_AUCTION_CLEARING_PRICE",MDEntryType_AUCTION_CLEARING_PRICE_get, MDEntryType_AUCTION_CLEARING_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_BID",MDEntryType_BID_get, MDEntryType_BID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_RECOVERY_RATE_FOR_SHORT",MDEntryType_RECOVERY_RATE_FOR_SHORT_get, MDEntryType_RECOVERY_RATE_FOR_SHORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_SIMULATED_BUY_PRICE",MDEntryType_SIMULATED_BUY_PRICE_get, MDEntryType_SIMULATED_BUY_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_EARLY_PRICES",MDEntryType_EARLY_PRICES_get, MDEntryType_EARLY_PRICES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_TRADINGLOW",MDEntryType_TRADINGLOW_get, MDEntryType_TRADINGLOW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_TRADING_SESSION_HIGH_PRICE",MDEntryType_TRADING_SESSION_HIGH_PRICE_get, MDEntryType_TRADING_SESSION_HIGH_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_INDEX_VALUE",MDEntryType_INDEX_VALUE_get, MDEntryType_INDEX_VALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_RECOVERY_RATE_FOR_LONG",MDEntryType_RECOVERY_RATE_FOR_LONG_get, MDEntryType_RECOVERY_RATE_FOR_LONG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS",MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS_get, MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_MID_PRICE",MDEntryType_MID_PRICE_get, MDEntryType_MID_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_SETTLEMENT",MDEntryType_SETTLEMENT_get, MDEntryType_SETTLEMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_RECOVERY_RATE",MDEntryType_RECOVERY_RATE_get, MDEntryType_RECOVERY_RATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS",MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS_get, MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS",MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS_get, MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_TRADE_VOLUME",MDEntryType_TRADE_VOLUME_get, MDEntryType_TRADE_VOLUME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_MARGIN_RATE",MDEntryType_MARGIN_RATE_get, MDEntryType_MARGIN_RATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_SETTLE_LOW_PRICE",MDEntryType_SETTLE_LOW_PRICE_get, MDEntryType_SETTLE_LOW_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_SESSION_LOW_OFFER",MDEntryType_SESSION_LOW_OFFER_get, MDEntryType_SESSION_LOW_OFFER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_TRADINGVWAP",MDEntryType_TRADINGVWAP_get, MDEntryType_TRADINGVWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_SETTLEMENT_PRICE",MDEntryType_SETTLEMENT_PRICE_get, MDEntryType_SETTLEMENT_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_OFFER",MDEntryType_OFFER_get, MDEntryType_OFFER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegMoveType_FLOATING",PegMoveType_FLOATING_get, PegMoveType_FLOATING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegMoveType_FIXED",PegMoveType_FIXED_get, PegMoveType_FIXED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AvgPxIndicator_NOAVERAGEPRICING",AvgPxIndicator_NOAVERAGEPRICING_get, AvgPxIndicator_NOAVERAGEPRICING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AvgPxIndicator_NO_AVERAGE_PRICING",AvgPxIndicator_NO_AVERAGE_PRICING_get, AvgPxIndicator_NO_AVERAGE_PRICING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AvgPxIndicator_LASTTRADEAVERAGEPRICEGROUP",AvgPxIndicator_LASTTRADEAVERAGEPRICEGROUP_get, AvgPxIndicator_LASTTRADEAVERAGEPRICEGROUP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AvgPxIndicator_TRADE_IS_PART_OF_AN_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID",AvgPxIndicator_TRADE_IS_PART_OF_AN_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID_get, AvgPxIndicator_TRADE_IS_PART_OF_AN_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AvgPxIndicator_TRADEAVERAGEPRICEGROUP",AvgPxIndicator_TRADEAVERAGEPRICEGROUP_get, AvgPxIndicator_TRADEAVERAGEPRICEGROUP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AvgPxIndicator_LAST_TRADE_IS_THE_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID",AvgPxIndicator_LAST_TRADE_IS_THE_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID_get, AvgPxIndicator_LAST_TRADE_IS_THE_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CancellationRights_NO_WAIVER_AGREEMENT",CancellationRights_NO_WAIVER_AGREEMENT_get, CancellationRights_NO_WAIVER_AGREEMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CancellationRights_NO_M",CancellationRights_NO_M_get, CancellationRights_NO_M_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CancellationRights_NO_N",CancellationRights_NO_N_get, CancellationRights_NO_N_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CancellationRights_NOINSTIT",CancellationRights_NOINSTIT_get, CancellationRights_NOINSTIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CancellationRights_NO_INSTITUTIONAL",CancellationRights_NO_INSTITUTIONAL_get, CancellationRights_NO_INSTITUTIONAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CancellationRights_YES",CancellationRights_YES_get, CancellationRights_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CancellationRights_NO_O",CancellationRights_NO_O_get, CancellationRights_NO_O_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CancellationRights_NOEXECONLY",CancellationRights_NOEXECONLY_get, CancellationRights_NOEXECONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CancellationRights_NO_EXECUTION_ONLY",CancellationRights_NO_EXECUTION_ONLY_get, CancellationRights_NO_EXECUTION_ONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CancellationRights_NOWAIVER",CancellationRights_NOWAIVER_get, CancellationRights_NOWAIVER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecPriceType_CREATIONPRICEADJAMT",ExecPriceType_CREATIONPRICEADJAMT_get, ExecPriceType_CREATIONPRICEADJAMT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecPriceType_CREATION_PRICE",ExecPriceType_CREATION_PRICE_get, ExecPriceType_CREATION_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecPriceType_CREATIONPRICE",ExecPriceType_CREATIONPRICE_get, ExecPriceType_CREATIONPRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecPriceType_SINGLEPRICE",ExecPriceType_SINGLEPRICE_get, ExecPriceType_SINGLEPRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_PERCENT",ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_PERCENT_get, ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_PERCENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecPriceType_OFFERPRICE",ExecPriceType_OFFERPRICE_get, ExecPriceType_OFFERPRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecPriceType_BIDPRICE",ExecPriceType_BIDPRICE_get, ExecPriceType_BIDPRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT",ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_get, ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecPriceType_CREATIONPRICEADJPCT",ExecPriceType_CREATIONPRICEADJPCT_get, ExecPriceType_CREATIONPRICEADJPCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_AMOUNT",ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_AMOUNT_get, ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecPriceType_OFFERPRICEMINUSADJAMT",ExecPriceType_OFFERPRICEMINUSADJAMT_get, ExecPriceType_OFFERPRICEMINUSADJAMT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_AMOUNT",ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_AMOUNT_get, ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_PERCENT",ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_PERCENT_get, ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_PERCENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecPriceType_OFFERPRICEMINUSADJPCT",ExecPriceType_OFFERPRICEMINUSADJPCT_get, ExecPriceType_OFFERPRICEMINUSADJPCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecPriceType_BID_PRICE",ExecPriceType_BID_PRICE_get, ExecPriceType_BID_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecPriceType_SINGLE_PRICE",ExecPriceType_SINGLE_PRICE_get, ExecPriceType_SINGLE_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT",ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_get, ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecPriceType_OFFER_PRICE",ExecPriceType_OFFER_PRICE_get, ExecPriceType_OFFER_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocSettlInstType_PHONEFORINSTRUCTIONS",AllocSettlInstType_PHONEFORINSTRUCTIONS_get, AllocSettlInstType_PHONEFORINSTRUCTIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocSettlInstType_SSIDBIDSPROVIDED",AllocSettlInstType_SSIDBIDSPROVIDED_get, AllocSettlInstType_SSIDBIDSPROVIDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocSettlInstType_FULLDETAILSPROVIDED",AllocSettlInstType_FULLDETAILSPROVIDED_get, AllocSettlInstType_FULLDETAILSPROVIDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocSettlInstType_USEDEFAULTINSTRUCTIONS",AllocSettlInstType_USEDEFAULTINSTRUCTIONS_get, AllocSettlInstType_USEDEFAULTINSTRUCTIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocSettlInstType_SSI_DB_IDS_PROVIDED",AllocSettlInstType_SSI_DB_IDS_PROVIDED_get, AllocSettlInstType_SSI_DB_IDS_PROVIDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocSettlInstType_PHONE_FOR_INSTRUCTIONS",AllocSettlInstType_PHONE_FOR_INSTRUCTIONS_get, AllocSettlInstType_PHONE_FOR_INSTRUCTIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocSettlInstType_DERIVE_FROM_PARAMETERS_PROVIDED",AllocSettlInstType_DERIVE_FROM_PARAMETERS_PROVIDED_get, AllocSettlInstType_DERIVE_FROM_PARAMETERS_PROVIDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocSettlInstType_FULL_DETAILS_PROVIDED",AllocSettlInstType_FULL_DETAILS_PROVIDED_get, AllocSettlInstType_FULL_DETAILS_PROVIDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocSettlInstType_USE_DEFAULT_INSTRUCTIONS",AllocSettlInstType_USE_DEFAULT_INSTRUCTIONS_get, AllocSettlInstType_USE_DEFAULT_INSTRUCTIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocSettlInstType_DERIVEFROMPARAMETERSPROVIDED",AllocSettlInstType_DERIVEFROMPARAMETERSPROVIDED_get, AllocSettlInstType_DERIVEFROMPARAMETERSPROVIDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StatsType_AVERAGE_PRICE",StatsType_AVERAGE_PRICE_get, StatsType_AVERAGE_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StatsType_HIGH",StatsType_HIGH_get, StatsType_HIGH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StatsType_EXCHANGE_LAST",StatsType_EXCHANGE_LAST_get, StatsType_EXCHANGE_LAST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StatsType_TURNOVER",StatsType_TURNOVER_get, StatsType_TURNOVER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesMode_SIMULATED",TradSesMode_SIMULATED_get, TradSesMode_SIMULATED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesMode_PRODUCTION",TradSesMode_PRODUCTION_get, TradSesMode_PRODUCTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesMode_TESTING",TradSesMode_TESTING_get, TradSesMode_TESTING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstSource_INSTITUTIONS_INSTRUCTIONS",SettlInstSource_INSTITUTIONS_INSTRUCTIONS_get, SettlInstSource_INSTITUTIONS_INSTRUCTIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstSource_BROKERS_INSTRUCTIONS",SettlInstSource_BROKERS_INSTRUCTIONS_get, SettlInstSource_BROKERS_INSTRUCTIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstSource_INVESTORCIV",SettlInstSource_INVESTORCIV_get, SettlInstSource_INVESTORCIV_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstSource_INVESTOR",SettlInstSource_INVESTOR_get, SettlInstSource_INVESTOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstSource_INSTINSTR",SettlInstSource_INSTINSTR_get, SettlInstSource_INSTINSTR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstSource_BROKERINSTR",SettlInstSource_BROKERINSTR_get, SettlInstSource_BROKERINSTR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExpType_DIFFERENCE",ExpType_DIFFERENCE_get, ExpType_DIFFERENCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExpType_FINAL_WILL_BE_EXERCISED",ExpType_FINAL_WILL_BE_EXERCISED_get, ExpType_FINAL_WILL_BE_EXERCISED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExpType_NON_AUTO_EXERCISE",ExpType_NON_AUTO_EXERCISE_get, ExpType_NON_AUTO_EXERCISE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExpType_CONTRARY_INTENTION",ExpType_CONTRARY_INTENTION_get, ExpType_CONTRARY_INTENTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExpType_AUTO_EXERCISE",ExpType_AUTO_EXERCISE_get, ExpType_AUTO_EXERCISE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstTransType_REPLACE",SettlInstTransType_REPLACE_get, SettlInstTransType_REPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstTransType_NEW",SettlInstTransType_NEW_get, SettlInstTransType_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstTransType_RESTATE",SettlInstTransType_RESTATE_get, SettlInstTransType_RESTATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstTransType_CANCEL",SettlInstTransType_CANCEL_get, SettlInstTransType_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestResult_TRADEREQUESTTYPENOTSUPPORTED",TradeRequestResult_TRADEREQUESTTYPENOTSUPPORTED_get, TradeRequestResult_TRADEREQUESTTYPENOTSUPPORTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestResult_INVALIDORUNKNOWNINSTRUMENT",TradeRequestResult_INVALIDORUNKNOWNINSTRUMENT_get, TradeRequestResult_INVALIDORUNKNOWNINSTRUMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestResult_INVALID_DESTINATION_REQUESTED",TradeRequestResult_INVALID_DESTINATION_REQUESTED_get, TradeRequestResult_INVALID_DESTINATION_REQUESTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestResult_UNAUTHORIZED_ROR_TRADE_CAPTURE_REPORT_REQUEST",TradeRequestResult_UNAUTHORIZED_ROR_TRADE_CAPTURE_REPORT_REQUEST_get, TradeRequestResult_UNAUTHORIZED_ROR_TRADE_CAPTURE_REPORT_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestResult_INVALIDTRANSPORTTYPEREQUESTED",TradeRequestResult_INVALIDTRANSPORTTYPEREQUESTED_get, TradeRequestResult_INVALIDTRANSPORTTYPEREQUESTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestResult_INVALIDPARTIES",TradeRequestResult_INVALIDPARTIES_get, TradeRequestResult_INVALIDPARTIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestResult_INVALIDDESTINATIONREQUESTED",TradeRequestResult_INVALIDDESTINATIONREQUESTED_get, TradeRequestResult_INVALIDDESTINATIONREQUESTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestResult_SUCCESSFUL",TradeRequestResult_SUCCESSFUL_get, TradeRequestResult_SUCCESSFUL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestResult_INVALID_OR_UNKNOWN_INSTRUMENT",TradeRequestResult_INVALID_OR_UNKNOWN_INSTRUMENT_get, TradeRequestResult_INVALID_OR_UNKNOWN_INSTRUMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestResult_OTHER",TradeRequestResult_OTHER_get, TradeRequestResult_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestResult_INVALID_TYPE_OF_TRADE_REQUESTED",TradeRequestResult_INVALID_TYPE_OF_TRADE_REQUESTED_get, TradeRequestResult_INVALID_TYPE_OF_TRADE_REQUESTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestResult_INVALID_PARTIES",TradeRequestResult_INVALID_PARTIES_get, TradeRequestResult_INVALID_PARTIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestResult_UNAUTHORIZEDFORTRADECAPTUREREPORTREQUEST",TradeRequestResult_UNAUTHORIZEDFORTRADECAPTUREREPORTREQUEST_get, TradeRequestResult_UNAUTHORIZEDFORTRADECAPTUREREPORTREQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestResult_NOT_AUTHORIZED",TradeRequestResult_NOT_AUTHORIZED_get, TradeRequestResult_NOT_AUTHORIZED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestResult_INVALID_TRANSPORT_TYPE_REQUESTED",TradeRequestResult_INVALID_TRANSPORT_TYPE_REQUESTED_get, TradeRequestResult_INVALID_TRANSPORT_TYPE_REQUESTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestResult_INVALIDTYPEOFTRADEREQUESTED",TradeRequestResult_INVALIDTYPEOFTRADEREQUESTED_get, TradeRequestResult_INVALIDTYPEOFTRADEREQUESTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestResult_TRADEREQUESTTYPE_NOT_SUPPORTED",TradeRequestResult_TRADEREQUESTTYPE_NOT_SUPPORTED_get, TradeRequestResult_TRADEREQUESTTYPE_NOT_SUPPORTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TestMessageIndicator_NO",TestMessageIndicator_NO_get, TestMessageIndicator_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TestMessageIndicator_YES",TestMessageIndicator_YES_get, TestMessageIndicator_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExpirationCycle_TRADING_ELIGIBILITY_EXPIRATION_SPECIFIED_IN_THE_DATE_AND_TIME_FIELDS_EVENTDATE",ExpirationCycle_TRADING_ELIGIBILITY_EXPIRATION_SPECIFIED_IN_THE_DATE_AND_TIME_FIELDS_EVENTDATE_get, ExpirationCycle_TRADING_ELIGIBILITY_EXPIRATION_SPECIFIED_IN_THE_DATE_AND_TIME_FIELDS_EVENTDATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExpirationCycle_EXPIREONTRADINGSESSIONOPEN",ExpirationCycle_EXPIREONTRADINGSESSIONOPEN_get, ExpirationCycle_EXPIREONTRADINGSESSIONOPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExpirationCycle_EXPIRE_ON_TRADING_SESSION_CLOSE",ExpirationCycle_EXPIRE_ON_TRADING_SESSION_CLOSE_get, ExpirationCycle_EXPIRE_ON_TRADING_SESSION_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExpirationCycle_EXPIRE_ON_TRADING_SESSION_OPEN",ExpirationCycle_EXPIRE_ON_TRADING_SESSION_OPEN_get, ExpirationCycle_EXPIRE_ON_TRADING_SESSION_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExpirationCycle_EXPIREONTRADINGSESSIONCLOSE",ExpirationCycle_EXPIREONTRADINGSESSIONCLOSE_get, ExpirationCycle_EXPIREONTRADINGSESSIONCLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocCancReplaceReason_ORIGINALDETAILSINCORRECT",AllocCancReplaceReason_ORIGINALDETAILSINCORRECT_get, AllocCancReplaceReason_ORIGINALDETAILSINCORRECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocCancReplaceReason_CHANGE_IN_UNDERLYING_ORDER_DETAILS",AllocCancReplaceReason_CHANGE_IN_UNDERLYING_ORDER_DETAILS_get, AllocCancReplaceReason_CHANGE_IN_UNDERLYING_ORDER_DETAILS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocCancReplaceReason_OTHER",AllocCancReplaceReason_OTHER_get, AllocCancReplaceReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocCancReplaceReason_ORIGINAL_DETAILS_INCOMPLETE_INCORRECT",AllocCancReplaceReason_ORIGINAL_DETAILS_INCOMPLETE_INCORRECT_get, AllocCancReplaceReason_ORIGINAL_DETAILS_INCOMPLETE_INCORRECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocCancReplaceReason_CHANGEINUNDERLYINGORDERDETAILS",AllocCancReplaceReason_CHANGEINUNDERLYINGORDERDETAILS_get, AllocCancReplaceReason_CHANGEINUNDERLYINGORDERDETAILS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_DUPLICATE_CLORDID",CxlRejReason_DUPLICATE_CLORDID_get, CxlRejReason_DUPLICATE_CLORDID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_UNABLETOPROCESS",CxlRejReason_UNABLETOPROCESS_get, CxlRejReason_UNABLETOPROCESS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE",CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_get, CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_DUPCLORDID",CxlRejReason_DUPCLORDID_get, CxlRejReason_DUPCLORDID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_DUPLICATE_CLORDID_RECEIVED",CxlRejReason_DUPLICATE_CLORDID_RECEIVED_get, CxlRejReason_DUPLICATE_CLORDID_RECEIVED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_UNKNOWN_ORDER",CxlRejReason_UNKNOWN_ORDER_get, CxlRejReason_UNKNOWN_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_TOO_LATE_TO_CANCEL",CxlRejReason_TOO_LATE_TO_CANCEL_get, CxlRejReason_TOO_LATE_TO_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_TOOLATE",CxlRejReason_TOOLATE_get, CxlRejReason_TOOLATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_ORIGORDMODTIME",CxlRejReason_ORIGORDMODTIME_get, CxlRejReason_ORIGORDMODTIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_INVALID_PRICE_INCREMENT",CxlRejReason_INVALID_PRICE_INCREMENT_get, CxlRejReason_INVALID_PRICE_INCREMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_BROKEROPT",CxlRejReason_BROKEROPT_get, CxlRejReason_BROKEROPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_ALREADYPENDINGCXL",CxlRejReason_ALREADYPENDINGCXL_get, CxlRejReason_ALREADYPENDINGCXL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_OTHER",CxlRejReason_OTHER_get, CxlRejReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_BROKER",CxlRejReason_BROKER_get, CxlRejReason_BROKER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_BROKER_OPTION",CxlRejReason_BROKER_OPTION_get, CxlRejReason_BROKER_OPTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_UNABLE_TO_PROCESS_ORDER_MASS_CANCEL_REQUEST",CxlRejReason_UNABLE_TO_PROCESS_ORDER_MASS_CANCEL_REQUEST_get, CxlRejReason_UNABLE_TO_PROCESS_ORDER_MASS_CANCEL_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_ORDER_ALREADY_IN_PENDING_CANCEL_OR_PENDING_REPLACE_STATUS",CxlRejReason_ORDER_ALREADY_IN_PENDING_CANCEL_OR_PENDING_REPLACE_STATUS_get, CxlRejReason_ORDER_ALREADY_IN_PENDING_CANCEL_OR_PENDING_REPLACE_STATUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND",CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_get, CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_ORIGORDMODTIMEMISMATCH",CxlRejReason_ORIGORDMODTIMEMISMATCH_get, CxlRejReason_ORIGORDMODTIMEMISMATCH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_ORIGORDMODTIME_DID_NOT_MATCH_LAST_TRANSACTTIME_OF_ORDER",CxlRejReason_ORIGORDMODTIME_DID_NOT_MATCH_LAST_TRANSACTTIME_OF_ORDER_get, CxlRejReason_ORIGORDMODTIME_DID_NOT_MATCH_LAST_TRANSACTTIME_OF_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_UNKNOWN",CxlRejReason_UNKNOWN_get, CxlRejReason_UNKNOWN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RespondentType_SPECIFIED_MARKET_PARTICIPANTS",RespondentType_SPECIFIED_MARKET_PARTICIPANTS_get, RespondentType_SPECIFIED_MARKET_PARTICIPANTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RespondentType_ALL_MARKET_MAKERS",RespondentType_ALL_MARKET_MAKERS_get, RespondentType_ALL_MARKET_MAKERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RespondentType_ALL_MARKET_PARTICIPANTS",RespondentType_ALL_MARKET_PARTICIPANTS_get, RespondentType_ALL_MARKET_PARTICIPANTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RespondentType_PRIMARY_MARKET_MAKER",RespondentType_PRIMARY_MARKET_MAKER_get, RespondentType_PRIMARY_MARKET_MAKER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DKReason_NO_MATCHING_ORDER",DKReason_NO_MATCHING_ORDER_get, DKReason_NO_MATCHING_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DKReason_UNKNOWNSYMBOL",DKReason_UNKNOWNSYMBOL_get, DKReason_UNKNOWNSYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DKReason_PRICE_EXCEEDS_LIMIT",DKReason_PRICE_EXCEEDS_LIMIT_get, DKReason_PRICE_EXCEEDS_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DKReason_QUANTITYEXCEEDSORDER",DKReason_QUANTITYEXCEEDSORDER_get, DKReason_QUANTITYEXCEEDSORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DKReason_QUANTITY_EXCEEDS_ORDER",DKReason_QUANTITY_EXCEEDS_ORDER_get, DKReason_QUANTITY_EXCEEDS_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DKReason_UNKNOWN_SYMBOL",DKReason_UNKNOWN_SYMBOL_get, DKReason_UNKNOWN_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DKReason_OTHER",DKReason_OTHER_get, DKReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DKReason_WRONGSIDE",DKReason_WRONGSIDE_get, DKReason_WRONGSIDE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DKReason_CALCULATIONDIFFERENCE",DKReason_CALCULATIONDIFFERENCE_get, DKReason_CALCULATIONDIFFERENCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DKReason_PRICEEXCEEDSLIMIT",DKReason_PRICEEXCEEDSLIMIT_get, DKReason_PRICEEXCEEDSLIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DKReason_WRONG_SIDE",DKReason_WRONG_SIDE_get, DKReason_WRONG_SIDE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DKReason_CALCULATION_DIFFERENCE",DKReason_CALCULATION_DIFFERENCE_get, DKReason_CALCULATION_DIFFERENCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DKReason_NOMATCH",DKReason_NOMATCH_get, DKReason_NOMATCH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PositionEffect_DEFAULT",PositionEffect_DEFAULT_get, PositionEffect_DEFAULT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PositionEffect_CLOSE",PositionEffect_CLOSE_get, PositionEffect_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PositionEffect_CLOSE_BUT_NOTIFY_ON_OPEN",PositionEffect_CLOSE_BUT_NOTIFY_ON_OPEN_get, PositionEffect_CLOSE_BUT_NOTIFY_ON_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PositionEffect_OPEN",PositionEffect_OPEN_get, PositionEffect_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PositionEffect_FIFO",PositionEffect_FIFO_get, PositionEffect_FIFO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PositionEffect_ROLLED",PositionEffect_ROLLED_get, PositionEffect_ROLLED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerAction_ACTIVATE",TriggerAction_ACTIVATE_get, TriggerAction_ACTIVATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerAction_MODIFY",TriggerAction_MODIFY_get, TriggerAction_MODIFY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerAction_CANCEL",TriggerAction_CANCEL_get, TriggerAction_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_BILATERALNETTINGONLY",ClearingInstruction_BILATERALNETTINGONLY_get, ClearingInstruction_BILATERALNETTINGONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_SPECIALTRADE",ClearingInstruction_SPECIALTRADE_get, ClearingInstruction_SPECIALTRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_EXCLUDE_FROM_ALL_NETTING",ClearingInstruction_EXCLUDE_FROM_ALL_NETTING_get, ClearingInstruction_EXCLUDE_FROM_ALL_NETTING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_AUTOMATIC_POSTING_MODE",ClearingInstruction_AUTOMATIC_POSTING_MODE_get, ClearingInstruction_AUTOMATIC_POSTING_MODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_EXCLEARING",ClearingInstruction_EXCLEARING_get, ClearingInstruction_EXCLEARING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_MULTILATERAL_NETTING",ClearingInstruction_MULTILATERAL_NETTING_get, ClearingInstruction_MULTILATERAL_NETTING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_CLEARAGAINSTCENTRALCOUNTERPARTY",ClearingInstruction_CLEARAGAINSTCENTRALCOUNTERPARTY_get, ClearingInstruction_CLEARAGAINSTCENTRALCOUNTERPARTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_EXCLUDE_FROM_CENTRAL_COUNTERPARTY",ClearingInstruction_EXCLUDE_FROM_CENTRAL_COUNTERPARTY_get, ClearingInstruction_EXCLUDE_FROM_CENTRAL_COUNTERPARTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_AUTOMATIC_GIVE_UP_MODE",ClearingInstruction_AUTOMATIC_GIVE_UP_MODE_get, ClearingInstruction_AUTOMATIC_GIVE_UP_MODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_CUSTOMER_TRADE",ClearingInstruction_CUSTOMER_TRADE_get, ClearingInstruction_CUSTOMER_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_AUTOMATICPOSTINGMODETRADEPOSTINGTOTHEPOSITIONACCOUNTNUMBERSPECIFIED",ClearingInstruction_AUTOMATICPOSTINGMODETRADEPOSTINGTOTHEPOSITIONACCOUNTNUMBERSPECIFIED_get, ClearingInstruction_AUTOMATICPOSTINGMODETRADEPOSTINGTOTHEPOSITIONACCOUNTNUMBERSPECIFIED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_EX_CLEARING",ClearingInstruction_EX_CLEARING_get, ClearingInstruction_EX_CLEARING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_QUALIFIEDSERVICEREPRESENTATIVEQSR",ClearingInstruction_QUALIFIEDSERVICEREPRESENTATIVEQSR_get, ClearingInstruction_QUALIFIEDSERVICEREPRESENTATIVEQSR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_MULTILATERALNETTING",ClearingInstruction_MULTILATERALNETTING_get, ClearingInstruction_MULTILATERALNETTING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_PROCESSNORMALLY",ClearingInstruction_PROCESSNORMALLY_get, ClearingInstruction_PROCESSNORMALLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_EXCLUDEFROMALLNETTING",ClearingInstruction_EXCLUDEFROMALLNETTING_get, ClearingInstruction_EXCLUDEFROMALLNETTING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_SELFCLEARING",ClearingInstruction_SELFCLEARING_get, ClearingInstruction_SELFCLEARING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_CLEAR_AGAINST_CENTRAL_COUNTERPARTY",ClearingInstruction_CLEAR_AGAINST_CENTRAL_COUNTERPARTY_get, ClearingInstruction_CLEAR_AGAINST_CENTRAL_COUNTERPARTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_BILATERAL_NETTING_ONLY",ClearingInstruction_BILATERAL_NETTING_ONLY_get, ClearingInstruction_BILATERAL_NETTING_ONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_EXCLUDEFROMCENTRALCOUNTERPARTY",ClearingInstruction_EXCLUDEFROMCENTRALCOUNTERPARTY_get, ClearingInstruction_EXCLUDEFROMCENTRALCOUNTERPARTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_MANUALMODEPREPOSTINGANDORPREGIVEUP",ClearingInstruction_MANUALMODEPREPOSTINGANDORPREGIVEUP_get, ClearingInstruction_MANUALMODEPREPOSTINGANDORPREGIVEUP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_CUSTOMERTRADE",ClearingInstruction_CUSTOMERTRADE_get, ClearingInstruction_CUSTOMERTRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_PROCESS_NORMALLY",ClearingInstruction_PROCESS_NORMALLY_get, ClearingInstruction_PROCESS_NORMALLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_SPECIAL_TRADE",ClearingInstruction_SPECIAL_TRADE_get, ClearingInstruction_SPECIAL_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_MANUAL_MODE",ClearingInstruction_MANUAL_MODE_get, ClearingInstruction_MANUAL_MODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE_QSR",ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE_QSR_get, ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE_QSR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_AUTOMATICGIVEUPMODETRADEGIVEUPTOTHEGIVEUPDESTINATIONNUMBERSPECIFIED",ClearingInstruction_AUTOMATICGIVEUPMODETRADEGIVEUPTOTHEGIVEUPDESTINATIONNUMBERSPECIFIED_get, ClearingInstruction_AUTOMATICGIVEUPMODETRADEGIVEUPTOTHEGIVEUPDESTINATIONNUMBERSPECIFIED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_SELF_CLEARING",ClearingInstruction_SELF_CLEARING_get, ClearingInstruction_SELF_CLEARING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OpenCloseSettlFlag_SESSION_OPEN",OpenCloseSettlFlag_SESSION_OPEN_get, OpenCloseSettlFlag_SESSION_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OpenCloseSettlFlag_EXPECTED_ENTRY",OpenCloseSettlFlag_EXPECTED_ENTRY_get, OpenCloseSettlFlag_EXPECTED_ENTRY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OpenCloseSettlFlag_THEORETICALPRICE",OpenCloseSettlFlag_THEORETICALPRICE_get, OpenCloseSettlFlag_THEORETICALPRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OpenCloseSettlFlag_ENTRYFROMPREVBUSINESSDAY",OpenCloseSettlFlag_ENTRYFROMPREVBUSINESSDAY_get, OpenCloseSettlFlag_ENTRYFROMPREVBUSINESSDAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OpenCloseSettlFlag_DAILY_OPEN",OpenCloseSettlFlag_DAILY_OPEN_get, OpenCloseSettlFlag_DAILY_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OpenCloseSettlFlag_DAILYOPEN",OpenCloseSettlFlag_DAILYOPEN_get, OpenCloseSettlFlag_DAILYOPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OpenCloseSettlFlag_THEORETICAL_PRICE_VALUE",OpenCloseSettlFlag_THEORETICAL_PRICE_VALUE_get, OpenCloseSettlFlag_THEORETICAL_PRICE_VALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OpenCloseSettlFlag_DELIVERY_SETTLEMENT_ENTRY",OpenCloseSettlFlag_DELIVERY_SETTLEMENT_ENTRY_get, OpenCloseSettlFlag_DELIVERY_SETTLEMENT_ENTRY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OpenCloseSettlFlag_ENTRY_FROM_PREVIOUS_BUSINESS_DAY",OpenCloseSettlFlag_ENTRY_FROM_PREVIOUS_BUSINESS_DAY_get, OpenCloseSettlFlag_ENTRY_FROM_PREVIOUS_BUSINESS_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OpenCloseSettlFlag_DELIVERYSETTLEMENT",OpenCloseSettlFlag_DELIVERYSETTLEMENT_get, OpenCloseSettlFlag_DELIVERYSETTLEMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OpenCloseSettlFlag_SESSIONOPEN",OpenCloseSettlFlag_SESSIONOPEN_get, OpenCloseSettlFlag_SESSIONOPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OpenCloseSettlFlag_EXPECTEDENTRY",OpenCloseSettlFlag_EXPECTEDENTRY_get, OpenCloseSettlFlag_EXPECTEDENTRY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionMoveType_FLOATING",DiscretionMoveType_FLOATING_get, DiscretionMoveType_FLOATING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionMoveType_FIXED",DiscretionMoveType_FIXED_get, DiscretionMoveType_FIXED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDUpdateType_INCREMENTAL_REFRESH",MDUpdateType_INCREMENTAL_REFRESH_get, MDUpdateType_INCREMENTAL_REFRESH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDUpdateType_FULL_REFRESH",MDUpdateType_FULL_REFRESH_get, MDUpdateType_FULL_REFRESH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDUpdateType_FULL",MDUpdateType_FULL_get, MDUpdateType_FULL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDUpdateType_INCREMENTAL",MDUpdateType_INCREMENTAL_get, MDUpdateType_INCREMENTAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TickDirection_MINUS_TICK",TickDirection_MINUS_TICK_get, TickDirection_MINUS_TICK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TickDirection_ZERO_PLUS_TICK",TickDirection_ZERO_PLUS_TICK_get, TickDirection_ZERO_PLUS_TICK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TickDirection_ZERO_MINUS_TICK",TickDirection_ZERO_MINUS_TICK_get, TickDirection_ZERO_MINUS_TICK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TickDirection_PLUS_TICK",TickDirection_PLUS_TICK_get, TickDirection_PLUS_TICK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TickDirection_PLUS",TickDirection_PLUS_get, TickDirection_PLUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TickDirection_ZEROPLUS",TickDirection_ZEROPLUS_get, TickDirection_ZEROPLUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TickDirection_MINUS",TickDirection_MINUS_get, TickDirection_MINUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TickDirection_ZEROMINUS",TickDirection_ZEROMINUS_get, TickDirection_ZEROMINUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_MARK_TO_MARKET_YIELD",YieldType_MARK_TO_MARKET_YIELD_get, YieldType_MARK_TO_MARKET_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER",YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER_get, YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_MATURITY",YieldType_YIELD_TO_MATURITY_get, YieldType_YIELD_TO_MATURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELDTOTENDERDATE",YieldType_YIELDTOTENDERDATE_get, YieldType_YIELDTOTENDERDATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_PREVIOUS_CLOSE_YIELD",YieldType_PREVIOUS_CLOSE_YIELD_get, YieldType_PREVIOUS_CLOSE_YIELD_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",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, 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_YIELDTOSHORTESTAVERAGELIFE",YieldType_YIELDTOSHORTESTAVERAGELIFE_get, YieldType_YIELDTOSHORTESTAVERAGELIFE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_AT_ISSUE",YieldType_YIELD_AT_ISSUE_get, YieldType_YIELD_AT_ISSUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_NEXT_REFUND",YieldType_YIELD_TO_NEXT_REFUND_get, YieldType_YIELD_TO_NEXT_REFUND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELDATISSUE",YieldType_YIELDATISSUE_get, YieldType_YIELDATISSUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_CLOSINGYIELD",YieldType_CLOSINGYIELD_get, YieldType_CLOSINGYIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_GVNTEQUIVALENTYIELD",YieldType_GVNTEQUIVALENTYIELD_get, YieldType_GVNTEQUIVALENTYIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_ANNUALYIELD",YieldType_ANNUALYIELD_get, YieldType_ANNUALYIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_AFTER_TAX_YIELD",YieldType_AFTER_TAX_YIELD_get, YieldType_AFTER_TAX_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_GVNT_EQUIVALENT_YIELD",YieldType_GVNT_EQUIVALENT_YIELD_get, YieldType_GVNT_EQUIVALENT_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELDCHANGESINCECLOSE",YieldType_YIELDCHANGESINCECLOSE_get, YieldType_YIELDCHANGESINCECLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELDTOMATURITY",YieldType_YIELDTOMATURITY_get, YieldType_YIELDTOMATURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE_SAME_AS_AVGLIFE_ABOVE",YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE_SAME_AS_AVGLIFE_ABOVE_get, 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",YieldType_YIELD_CHANGE_SINCE_CLOSE_THE_CHANGE_IN_THE_YIELD_SINCE_THE_PREVIOUS_DAYS_CLOSING_YIELD_get, YieldType_YIELD_CHANGE_SINCE_CLOSE_THE_CHANGE_IN_THE_YIELD_SINCE_THE_PREVIOUS_DAYS_CLOSING_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_SEMI",YieldType_SEMI_get, YieldType_SEMI_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",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, 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_CLOSING_YIELD_MOST_RECENT_YEAR",YieldType_CLOSING_YIELD_MOST_RECENT_YEAR_get, YieldType_CLOSING_YIELD_MOST_RECENT_YEAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_NEXT_CALL",YieldType_YIELD_TO_NEXT_CALL_get, YieldType_YIELD_TO_NEXT_CALL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_CHANGE_SINCE_CLOSE",YieldType_YIELD_CHANGE_SINCE_CLOSE_get, YieldType_YIELD_CHANGE_SINCE_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_PROCEEDS_YIELD",YieldType_PROCEEDS_YIELD_get, YieldType_PROCEEDS_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_MATURITY_THE_YIELD_OF_A_BOND_TO_ITS_MATURITY_DATE",YieldType_YIELD_TO_MATURITY_THE_YIELD_OF_A_BOND_TO_ITS_MATURITY_DATE_get, YieldType_YIELD_TO_MATURITY_THE_YIELD_OF_A_BOND_TO_ITS_MATURITY_DATE_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",YieldType_TAX_EQUIVALENT_YIELD_THE_AFTER_TAX_YIELD_GROSSED_UP_BY_THE_MAXIMUM_FEDERAL_TAX_RATE_OF_396_FOR_COMPARISON_TO_TAXABLE_YIELDS_get, 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",YieldType_INVERSE_FLOATER_BOND_YIELD_INVERSE_FLOATER_SEMI_ANNUAL_BOND_EQUIVALENT_RATE_get, YieldType_INVERSE_FLOATER_BOND_YIELD_INVERSE_FLOATER_SEMI_ANNUAL_BOND_EQUIVALENT_RATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_CURRENT_YIELD",YieldType_CURRENT_YIELD_get, YieldType_CURRENT_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_SIMPLEYIELD",YieldType_SIMPLEYIELD_get, YieldType_SIMPLEYIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_TRUEGROSSYIELD",YieldType_TRUEGROSSYIELD_get, YieldType_TRUEGROSSYIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_COMPOUND_YIELD",YieldType_COMPOUND_YIELD_get, YieldType_COMPOUND_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_CLOSINGYIELDMOSTRECENTYEAR",YieldType_CLOSINGYIELDMOSTRECENTYEAR_get, YieldType_CLOSINGYIELDMOSTRECENTYEAR_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",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, 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_YIELD_TO_NEXT_PUT_THE_YIELD_TO_THE_DATE_AT_WHICH_THE_BOND_HOLDER_CAN_NEXT_PUT_THE_BOND_TO_THE_ISSUER",YieldType_YIELD_TO_NEXT_PUT_THE_YIELD_TO_THE_DATE_AT_WHICH_THE_BOND_HOLDER_CAN_NEXT_PUT_THE_BOND_TO_THE_ISSUER_get, 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",YieldType_GOVERNMENT_EQUIVALENT_YIELD_ASK_YIELD_BASED_ON_SEMI_ANNUAL_COUPONS_COMPOUNDING_IN_ALL_PERIODS_AND_ACTUAL_ACTUAL_CALENDAR_get, 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",YieldType_YIELD_TO_TENDER_DATE_THE_YIELD_ON_A_MUNICIPAL_BOND_TO_ITS_MANDATORY_TENDER_DATE_get, 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",YieldType_YIELD_TO_AVG_MATURITY_get, YieldType_YIELD_TO_AVG_MATURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_TENDER_DATE",YieldType_YIELD_TO_TENDER_DATE_get, YieldType_YIELD_TO_TENDER_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_PROCEEDSYIELD",YieldType_PROCEEDSYIELD_get, YieldType_PROCEEDSYIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_OPEN_AVERAGE_YIELD_THE_AVERAGE_YIELD_OF_THE_RESPECTIVE_SECURITIES_IN_THE_PORTFOLIO",YieldType_OPEN_AVERAGE_YIELD_THE_AVERAGE_YIELD_OF_THE_RESPECTIVE_SECURITIES_IN_THE_PORTFOLIO_get, YieldType_OPEN_AVERAGE_YIELD_THE_AVERAGE_YIELD_OF_THE_RESPECTIVE_SECURITIES_IN_THE_PORTFOLIO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_ANNUAL_YIELD",YieldType_ANNUAL_YIELD_get, YieldType_ANNUAL_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_WORST",YieldType_YIELD_TO_WORST_get, YieldType_YIELD_TO_WORST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_BOOK_YIELD",YieldType_BOOK_YIELD_get, YieldType_BOOK_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_NEXT_PUT",YieldType_YIELD_TO_NEXT_PUT_get, YieldType_YIELD_TO_NEXT_PUT_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",YieldType_CLOSING_YIELD_MOST_RECENT_MONTH_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_MONTHS_END_get, 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",YieldType_CLOSING_YIELD_MOST_RECENT_YEAR_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_YEARS_END_get, 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_OPENAVERAGEYIELD",YieldType_OPENAVERAGEYIELD_get, YieldType_OPENAVERAGEYIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_TRUE_YIELD",YieldType_TRUE_YIELD_get, YieldType_TRUE_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_TAX_EQUIVALENT_YIELD",YieldType_TAX_EQUIVALENT_YIELD_get, YieldType_TAX_EQUIVALENT_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_TRUE_GROSS_YIELD",YieldType_TRUE_GROSS_YIELD_get, YieldType_TRUE_GROSS_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_INVERSE_FLOATER_BOND_YIELD",YieldType_INVERSE_FLOATER_BOND_YIELD_get, YieldType_INVERSE_FLOATER_BOND_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",YieldType_TRUE_YIELD_THE_YIELD_CALCULATED_WITH_COUPON_DATES_MOVED_FROM_A_WEEKEND_OR_HOLIDAY_TO_THE_NEXT_VALID_SETTLEMENT_DATE_get, 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",YieldType_SEMI_ANNUAL_YIELD_THE_YIELD_OF_A_BOND_WHOSE_COUPON_PAYMENTS_ARE_REINVESTED_SEMI_ANNUALLY_get, YieldType_SEMI_ANNUAL_YIELD_THE_YIELD_OF_A_BOND_WHOSE_COUPON_PAYMENTS_ARE_REINVESTED_SEMI_ANNUALLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_AFTERTAXYIELD",YieldType_AFTERTAXYIELD_get, YieldType_AFTERTAXYIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_CLOSING_YIELD_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE",YieldType_CLOSING_YIELD_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_get, YieldType_CLOSING_YIELD_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELDTOWORSTCONVENTION",YieldType_YIELDTOWORSTCONVENTION_get, YieldType_YIELDTOWORSTCONVENTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_PREVIOUS_CLOSE_YIELD_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_1_DAY_AGO",YieldType_PREVIOUS_CLOSE_YIELD_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_1_DAY_AGO_get, YieldType_PREVIOUS_CLOSE_YIELD_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_1_DAY_AGO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_COMPOUNDYIELD",YieldType_COMPOUNDYIELD_get, YieldType_COMPOUNDYIELD_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",YieldType_YIELD_VALUE_OF_1_32_THE_AMOUNT_THAT_THE_YIELD_WILL_CHANGE_FOR_A_1_32ND_CHANGE_IN_PRICE_get, 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_YIELD_TO_LONGEST_AVERAGE",YieldType_YIELD_TO_LONGEST_AVERAGE_get, YieldType_YIELD_TO_LONGEST_AVERAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_PREVIOUSCLOSEYIELD",YieldType_PREVIOUSCLOSEYIELD_get, YieldType_PREVIOUSCLOSEYIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_CLOSINGYIELDMOSTRECENTMONTH",YieldType_CLOSINGYIELDMOSTRECENTMONTH_get, YieldType_CLOSINGYIELDMOSTRECENTMONTH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_CLOSING_YIELD_MOST_RECENT_MONTH",YieldType_CLOSING_YIELD_MOST_RECENT_MONTH_get, YieldType_CLOSING_YIELD_MOST_RECENT_MONTH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_AVERAGE_LIFE_THE_YIELD_ASSUMING_THAT_ALL_SINKS",YieldType_YIELD_TO_AVERAGE_LIFE_THE_YIELD_ASSUMING_THAT_ALL_SINKS_get, 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",YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_QUARTERS_END_get, 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",YieldType_YIELD_TO_SHORTEST_AVERAGE_get, YieldType_YIELD_TO_SHORTEST_AVERAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_TAXEQUIVALENTYIELD",YieldType_TAXEQUIVALENTYIELD_get, YieldType_TAXEQUIVALENTYIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_MOSTRECENTCLOSINGYIELD",YieldType_MOSTRECENTCLOSINGYIELD_get, YieldType_MOSTRECENTCLOSINGYIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_MARKTOMARKETYIELD",YieldType_MARKTOMARKETYIELD_get, YieldType_MARKTOMARKETYIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_CURRENTYIELD",YieldType_CURRENTYIELD_get, YieldType_CURRENTYIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_OPEN_AVERAGE_YIELD",YieldType_OPEN_AVERAGE_YIELD_get, 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",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, 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_YIELD_WITH_INFLATION_ASSUMPTION",YieldType_YIELD_WITH_INFLATION_ASSUMPTION_get, YieldType_YIELD_WITH_INFLATION_ASSUMPTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELDTONEXTREFUNDSINKING",YieldType_YIELDTONEXTREFUNDSINKING_get, YieldType_YIELDTONEXTREFUNDSINKING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_PROCEEDS_YIELD_THE_CD_EQUIVALENT_YIELD_WHEN_THE_REMAINING_TIME_TO_MATURITY_IS_LESS_THAN_TWO_YEARS",YieldType_PROCEEDS_YIELD_THE_CD_EQUIVALENT_YIELD_WHEN_THE_REMAINING_TIME_TO_MATURITY_IS_LESS_THAN_TWO_YEARS_get, 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_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",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, 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",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, 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_SIMPLE_YIELD",YieldType_SIMPLE_YIELD_get, YieldType_SIMPLE_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_AVERAGE_MATURITY",YieldType_YIELD_TO_AVERAGE_MATURITY_get, 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",YieldType_YIELD_TO_WORST_CONVENTION_THE_LOWEST_YIELD_TO_ALL_POSSIBLE_REDEMPTION_DATE_SCENARIOS_get, 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",YieldType_YIELD_TO_NEXT_CALL_THE_YIELD_OF_A_BOND_TO_THE_NEXT_POSSIBLE_CALL_DATE_get, YieldType_YIELD_TO_NEXT_CALL_THE_YIELD_OF_A_BOND_TO_THE_NEXT_POSSIBLE_CALL_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELDTOAVGMATURITY",YieldType_YIELDTOAVGMATURITY_get, YieldType_YIELDTOAVGMATURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELDTOLONGESTAVERAGELIFE",YieldType_YIELDTOLONGESTAVERAGELIFE_get, YieldType_YIELDTOLONGESTAVERAGELIFE_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",YieldType_ANNUAL_YIELD_THE_ANNUAL_INTEREST_OR_DIVIDEND_INCOME_AN_INVESTMENT_EARNS_EXPRESSED_AS_A_PERCENTAGE_OF_THE_INVESTMENTS_TOTAL_VALUE_get, 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",YieldType_SEMI_ANNUAL_YIELD_get, YieldType_SEMI_ANNUAL_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_MOST_RECENT_CLOSING_YIELD",YieldType_MOST_RECENT_CLOSING_YIELD_get, YieldType_MOST_RECENT_CLOSING_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE",YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE_get, YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_CLOSING_YIELD",YieldType_CLOSING_YIELD_get, YieldType_CLOSING_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELDINFLATIONASSUMPTION",YieldType_YIELDINFLATIONASSUMPTION_get, YieldType_YIELDINFLATIONASSUMPTION_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",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, 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_TRUEYIELD",YieldType_TRUEYIELD_get, YieldType_TRUEYIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_CLOSINGYIELDMOSTRECENTQUARTER",YieldType_CLOSINGYIELDMOSTRECENTQUARTER_get, YieldType_CLOSINGYIELDMOSTRECENTQUARTER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_VALUE_OF_1_32",YieldType_YIELD_VALUE_OF_1_32_get, YieldType_YIELD_VALUE_OF_1_32_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE",YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE_get, YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_INVFLOATERBONDYIELD",YieldType_INVFLOATERBONDYIELD_get, YieldType_INVFLOATERBONDYIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_MOST_RECENT_CLOSING_YIELD_THE_LAST_AVAILABLE_YIELD_STORED_IN_HISTORY_COMPUTED_USING_PRICE",YieldType_MOST_RECENT_CLOSING_YIELD_THE_LAST_AVAILABLE_YIELD_STORED_IN_HISTORY_COMPUTED_USING_PRICE_get, YieldType_MOST_RECENT_CLOSING_YIELD_THE_LAST_AVAILABLE_YIELD_STORED_IN_HISTORY_COMPUTED_USING_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELDTONEXTPUT",YieldType_YIELDTONEXTPUT_get, YieldType_YIELDTONEXTPUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELDTONEXTCALL",YieldType_YIELDTONEXTCALL_get, YieldType_YIELDTONEXTCALL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_SIMPLE_YIELD_THE_YIELD_OF_A_BOND_ASSUMING_NO_REINVESTMENT_OF_COUPON_PAYMENTS",YieldType_SIMPLE_YIELD_THE_YIELD_OF_A_BOND_ASSUMING_NO_REINVESTMENT_OF_COUPON_PAYMENTS_get, YieldType_SIMPLE_YIELD_THE_YIELD_OF_A_BOND_ASSUMING_NO_REINVESTMENT_OF_COUPON_PAYMENTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_BOOKYIELD",YieldType_BOOKYIELD_get, YieldType_BOOKYIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELDVALUEOF132",YieldType_YIELDVALUEOF132_get, YieldType_YIELDVALUEOF132_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegScope_NATIONAL_XXCLUDING_LOCAL",PegScope_NATIONAL_XXCLUDING_LOCAL_get, PegScope_NATIONAL_XXCLUDING_LOCAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegScope_NATIONAL_EXCLUDING_LOCAL",PegScope_NATIONAL_EXCLUDING_LOCAL_get, PegScope_NATIONAL_EXCLUDING_LOCAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegScope_LOCAL",PegScope_LOCAL_get, PegScope_LOCAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegScope_NATIONALEXCLUDINGLOCAL",PegScope_NATIONALEXCLUDINGLOCAL_get, PegScope_NATIONALEXCLUDINGLOCAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegScope_GLOBAL",PegScope_GLOBAL_get, PegScope_GLOBAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegScope_NATIONAL",PegScope_NATIONAL_get, PegScope_NATIONAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegScope_LOCALEXCHANGEECNATS",PegScope_LOCALEXCHANGEECNATS_get, PegScope_LOCALEXCHANGEECNATS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlDeliveryType_TRI_PARTY",SettlDeliveryType_TRI_PARTY_get, SettlDeliveryType_TRI_PARTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlDeliveryType_HOLD_IN_CUSTODY",SettlDeliveryType_HOLD_IN_CUSTODY_get, SettlDeliveryType_HOLD_IN_CUSTODY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlDeliveryType_FREE",SettlDeliveryType_FREE_get, SettlDeliveryType_FREE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlDeliveryType_VERSUS_PAYMENT_DELIVER",SettlDeliveryType_VERSUS_PAYMENT_DELIVER_get, SettlDeliveryType_VERSUS_PAYMENT_DELIVER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlDeliveryType_FREE_DELIVER",SettlDeliveryType_FREE_DELIVER_get, SettlDeliveryType_FREE_DELIVER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlDeliveryType_VERSUS_PAYMENT",SettlDeliveryType_VERSUS_PAYMENT_get, SettlDeliveryType_VERSUS_PAYMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionLimitType_STRICT",DiscretionLimitType_STRICT_get, DiscretionLimitType_STRICT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionLimitType_ORWORSE",DiscretionLimitType_ORWORSE_get, DiscretionLimitType_ORWORSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionLimitType_OR_BETTER",DiscretionLimitType_OR_BETTER_get, DiscretionLimitType_OR_BETTER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionLimitType_OR_WORSE",DiscretionLimitType_OR_WORSE_get, DiscretionLimitType_OR_WORSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionLimitType_ORBETTER",DiscretionLimitType_ORBETTER_get, DiscretionLimitType_ORBETTER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyDetailsRequestResult_UNSUPPORTED_PARTYLISTRESPONSETYPE",PartyDetailsRequestResult_UNSUPPORTED_PARTYLISTRESPONSETYPE_get, PartyDetailsRequestResult_UNSUPPORTED_PARTYLISTRESPONSETYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyDetailsRequestResult_PARTIES_OR_PARTY_DETAILS_DATA_TEMPORARILY_UNAVAILABLE",PartyDetailsRequestResult_PARTIES_OR_PARTY_DETAILS_DATA_TEMPORARILY_UNAVAILABLE_get, PartyDetailsRequestResult_PARTIES_OR_PARTY_DETAILS_DATA_TEMPORARILY_UNAVAILABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyDetailsRequestResult_VALID_REQUEST",PartyDetailsRequestResult_VALID_REQUEST_get, PartyDetailsRequestResult_VALID_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyDetailsRequestResult_REQUEST_FOR_PARTIES_DATA_NOT_SUPPORTED",PartyDetailsRequestResult_REQUEST_FOR_PARTIES_DATA_NOT_SUPPORTED_get, PartyDetailsRequestResult_REQUEST_FOR_PARTIES_DATA_NOT_SUPPORTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyDetailsRequestResult_NO_PARTIES_OR_PARTY_DETAILS_FOUND_THAT_MATCH_SELECTION_CRITERIA",PartyDetailsRequestResult_NO_PARTIES_OR_PARTY_DETAILS_FOUND_THAT_MATCH_SELECTION_CRITERIA_get, PartyDetailsRequestResult_NO_PARTIES_OR_PARTY_DETAILS_FOUND_THAT_MATCH_SELECTION_CRITERIA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyDetailsRequestResult_INVALID_OR_UNSUPPORTED_REQUEST",PartyDetailsRequestResult_INVALID_OR_UNSUPPORTED_REQUEST_get, PartyDetailsRequestResult_INVALID_OR_UNSUPPORTED_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyDetailsRequestResult_OTHER",PartyDetailsRequestResult_OTHER_get, PartyDetailsRequestResult_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyDetailsRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_PARTIES_OR_PARTY_DETAILS_DATA",PartyDetailsRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_PARTIES_OR_PARTY_DETAILS_DATA_get, PartyDetailsRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_PARTIES_OR_PARTY_DETAILS_DATA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExerciseMethod_AUTOMATIC",ExerciseMethod_AUTOMATIC_get, ExerciseMethod_AUTOMATIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExerciseMethod_MANUAL",ExerciseMethod_MANUAL_get, ExerciseMethod_MANUAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"WorkingIndicator_NO",WorkingIndicator_NO_get, WorkingIndicator_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"WorkingIndicator_YES",WorkingIndicator_YES_get, WorkingIndicator_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SideMultiLegReportingType_INDIVIDUALLEGOFAMULTILEGSECURITY",SideMultiLegReportingType_INDIVIDUALLEGOFAMULTILEGSECURITY_get, SideMultiLegReportingType_INDIVIDUALLEGOFAMULTILEGSECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SideMultiLegReportingType_SINGLE_SECURITY",SideMultiLegReportingType_SINGLE_SECURITY_get, SideMultiLegReportingType_SINGLE_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SideMultiLegReportingType_MULTILEG_SECURITY",SideMultiLegReportingType_MULTILEG_SECURITY_get, SideMultiLegReportingType_MULTILEG_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY",SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY_get, SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SideMultiLegReportingType_MULTILEGSECURITY",SideMultiLegReportingType_MULTILEGSECURITY_get, SideMultiLegReportingType_MULTILEGSECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SideMultiLegReportingType_SINGLESECURITY",SideMultiLegReportingType_SINGLESECURITY_get, SideMultiLegReportingType_SINGLESECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmRejReason_MISSINGSETTLEMENTINSTRUCTIONS",ConfirmRejReason_MISSINGSETTLEMENTINSTRUCTIONS_get, ConfirmRejReason_MISSINGSETTLEMENTINSTRUCTIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmRejReason_MISSING_SETTLEMENT_INSTRUCTIONS",ConfirmRejReason_MISSING_SETTLEMENT_INSTRUCTIONS_get, ConfirmRejReason_MISSING_SETTLEMENT_INSTRUCTIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmRejReason_MISMATCHEDACCOUNT",ConfirmRejReason_MISMATCHEDACCOUNT_get, ConfirmRejReason_MISMATCHEDACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmRejReason_MISMATCHED_ACCOUNT",ConfirmRejReason_MISMATCHED_ACCOUNT_get, ConfirmRejReason_MISMATCHED_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmRejReason_OTHER",ConfirmRejReason_OTHER_get, ConfirmRejReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidRequestTransType_NEW",BidRequestTransType_NEW_get, BidRequestTransType_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidRequestTransType_NO",BidRequestTransType_NO_get, BidRequestTransType_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidRequestTransType_CANCEL",BidRequestTransType_CANCEL_get, BidRequestTransType_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY",MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_get, MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP",MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP_get, MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY",MassActionRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_get, MassActionRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE",MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE_get, MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionRejectReason_INVALID_OR_UNKNOWN_CFICODE",MassActionRejectReason_INVALID_OR_UNKNOWN_CFICODE_get, MassActionRejectReason_INVALID_OR_UNKNOWN_CFICODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_SECURITY",MassActionRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_SECURITY_get, MassActionRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION",MassActionRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION_get, MassActionRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_SEGMENT",MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_SEGMENT_get, MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_SEGMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET",MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_get, MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionRejectReason_MASS_ACTION_NOT_SUPPORTED",MassActionRejectReason_MASS_ACTION_NOT_SUPPORTED_get, MassActionRejectReason_MASS_ACTION_NOT_SUPPORTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionRejectReason_OTHER",MassActionRejectReason_OTHER_get, MassActionRejectReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER",MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_get, MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionRejectReason_INVALID_OR_UNKNOWN_PRODUCT",MassActionRejectReason_INVALID_OR_UNKNOWN_PRODUCT_get, MassActionRejectReason_INVALID_OR_UNKNOWN_PRODUCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollApplType_GENERAL",CollApplType_GENERAL_get, CollApplType_GENERAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollApplType_SPECIFIC_DEPOSIT",CollApplType_SPECIFIC_DEPOSIT_get, CollApplType_SPECIFIC_DEPOSIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmType_CONFIRMATION",ConfirmType_CONFIRMATION_get, ConfirmType_CONFIRMATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmType_CONFIRMATION_REQUEST_REJECTED",ConfirmType_CONFIRMATION_REQUEST_REJECTED_get, ConfirmType_CONFIRMATION_REQUEST_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmType_CONFIRMATIONREQUESTREJECTED",ConfirmType_CONFIRMATIONREQUESTREJECTED_get, ConfirmType_CONFIRMATIONREQUESTREJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmType_STATUS",ConfirmType_STATUS_get, ConfirmType_STATUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDQuoteType_INDICATIVE",MDQuoteType_INDICATIVE_get, MDQuoteType_INDICATIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDQuoteType_RESTRICTED_TRADEABLE",MDQuoteType_RESTRICTED_TRADEABLE_get, MDQuoteType_RESTRICTED_TRADEABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDQuoteType_INDICATIVE_AND_TRADEABLE",MDQuoteType_INDICATIVE_AND_TRADEABLE_get, MDQuoteType_INDICATIVE_AND_TRADEABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDQuoteType_TRADEABLE",MDQuoteType_TRADEABLE_get, MDQuoteType_TRADEABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDQuoteType_COUNTER",MDQuoteType_COUNTER_get, MDQuoteType_COUNTER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QtyType_CONTRACTS",QtyType_CONTRACTS_get, QtyType_CONTRACTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QtyType_UNITS_OF_MEASURE_PER_TIME_UNIT",QtyType_UNITS_OF_MEASURE_PER_TIME_UNIT_get, QtyType_UNITS_OF_MEASURE_PER_TIME_UNIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QtyType_UNITS",QtyType_UNITS_get, QtyType_UNITS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRespType_END_TRADE",QuoteRespType_END_TRADE_get, QuoteRespType_END_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRespType_HITLIFT",QuoteRespType_HITLIFT_get, QuoteRespType_HITLIFT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRespType_HIT_LIFT",QuoteRespType_HIT_LIFT_get, QuoteRespType_HIT_LIFT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRespType_COVER",QuoteRespType_COVER_get, QuoteRespType_COVER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRespType_DONE_AWAY",QuoteRespType_DONE_AWAY_get, QuoteRespType_DONE_AWAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRespType_DONEAWAY",QuoteRespType_DONEAWAY_get, QuoteRespType_DONEAWAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRespType_TIMED_OUT",QuoteRespType_TIMED_OUT_get, QuoteRespType_TIMED_OUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRespType_PASS",QuoteRespType_PASS_get, QuoteRespType_PASS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRespType_EXPIRED",QuoteRespType_EXPIRED_get, QuoteRespType_EXPIRED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRespType_COUNTER",QuoteRespType_COUNTER_get, QuoteRespType_COUNTER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOINaturalFlag_NO",IOINaturalFlag_NO_get, IOINaturalFlag_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOINaturalFlag_YES",IOINaturalFlag_YES_get, IOINaturalFlag_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlObligSource_INSTRUCTIONS_OF_BROKER",SettlObligSource_INSTRUCTIONS_OF_BROKER_get, SettlObligSource_INSTRUCTIONS_OF_BROKER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlObligSource_INVESTOR",SettlObligSource_INVESTOR_get, SettlObligSource_INVESTOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlObligSource_INSTRUCTIONS_FOR_INSTITUTION",SettlObligSource_INSTRUCTIONS_FOR_INSTITUTION_get, SettlObligSource_INSTRUCTIONS_FOR_INSTITUTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_ON_HOURS_TRADE",TrdSubType_ON_HOURS_TRADE_get, TrdSubType_ON_HOURS_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_INTERIM_PROTECTED_TRADE",TrdSubType_INTERIM_PROTECTED_TRADE_get, TrdSubType_INTERIM_PROTECTED_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_K",TrdSubType_K_get, TrdSubType_K_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_LC",TrdSubType_LC_get, TrdSubType_LC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_WN",TrdSubType_WN_get, TrdSubType_WN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_CONVERTED_SWAP",TrdSubType_CONVERTED_SWAP_get, TrdSubType_CONVERTED_SWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_B",TrdSubType_B_get, TrdSubType_B_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_M",TrdSubType_M_get, TrdSubType_M_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_RT",TrdSubType_RT_get, TrdSubType_RT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_ONSET_DUE_TO_AN_ALLOCATION",TrdSubType_ONSET_DUE_TO_AN_ALLOCATION_get, TrdSubType_ONSET_DUE_TO_AN_ALLOCATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_CMTA",TrdSubType_CMTA_get, TrdSubType_CMTA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_INTERNAL_TRANSFER_OR_ADJUSTMENT",TrdSubType_INTERNAL_TRANSFER_OR_ADJUSTMENT_get, TrdSubType_INTERNAL_TRANSFER_OR_ADJUSTMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_DIFFERENTIAL_SPREAD",TrdSubType_DIFFERENTIAL_SPREAD_get, TrdSubType_DIFFERENTIAL_SPREAD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_TRANSACTION_FROM_EXERCISE",TrdSubType_TRANSACTION_FROM_EXERCISE_get, TrdSubType_TRANSACTION_FROM_EXERCISE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_TRANSACTION_FROM_ASSIGNMENT",TrdSubType_TRANSACTION_FROM_ASSIGNMENT_get, TrdSubType_TRANSACTION_FROM_ASSIGNMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_N",TrdSubType_N_get, TrdSubType_N_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT",TrdSubType_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT_get, TrdSubType_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_NR",TrdSubType_NR_get, TrdSubType_NR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_SW",TrdSubType_SW_get, TrdSubType_SW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_OTC_QUOTE",TrdSubType_OTC_QUOTE_get, TrdSubType_OTC_QUOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_ADVISORY_FOR_CONTRA_SIDE",TrdSubType_ADVISORY_FOR_CONTRA_SIDE_get, TrdSubType_ADVISORY_FOR_CONTRA_SIDE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_OFFSET_DUE_TO_AN_ALLOCATION",TrdSubType_OFFSET_DUE_TO_AN_ALLOCATION_get, TrdSubType_OFFSET_DUE_TO_AN_ALLOCATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_P",TrdSubType_P_get, TrdSubType_P_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_CROSSED_TRADE",TrdSubType_CROSSED_TRADE_get, TrdSubType_CROSSED_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_PA",TrdSubType_PA_get, TrdSubType_PA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_EXTERNAL_TRANSFER_OR_TRANSFER_OF_ACCOUNT",TrdSubType_EXTERNAL_TRANSFER_OR_TRANSFER_OF_ACCOUNT_get, TrdSubType_EXTERNAL_TRANSFER_OR_TRANSFER_OF_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_R",TrdSubType_R_get, TrdSubType_R_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_RO",TrdSubType_RO_get, TrdSubType_RO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_WT",TrdSubType_WT_get, TrdSubType_WT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_OFF_HOURS_TRADE",TrdSubType_OFF_HOURS_TRADE_get, TrdSubType_OFF_HOURS_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_REJECT_FOR_SUBMITTING_SIDE",TrdSubType_REJECT_FOR_SUBMITTING_SIDE_get, TrdSubType_REJECT_FOR_SUBMITTING_SIDE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_ONSET_DUT_TO_AN_ALLOCATION",TrdSubType_ONSET_DUT_TO_AN_ALLOCATION_get, TrdSubType_ONSET_DUT_TO_AN_ALLOCATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_AI",TrdSubType_AI_get, TrdSubType_AI_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_PC",TrdSubType_PC_get, TrdSubType_PC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_PN",TrdSubType_PN_get, TrdSubType_PN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_LARGE_IN_SCALE",TrdSubType_LARGE_IN_SCALE_get, TrdSubType_LARGE_IN_SCALE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_NM",TrdSubType_NM_get, TrdSubType_NM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_T",TrdSubType_T_get, TrdSubType_T_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_ACATS",TrdSubType_ACATS_get, TrdSubType_ACATS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecTransType_NEW",ExecTransType_NEW_get, ExecTransType_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecTransType_CORRECT",ExecTransType_CORRECT_get, ExecTransType_CORRECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecTransType_CANCEL",ExecTransType_CANCEL_get, ExecTransType_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecTransType_STATUS",ExecTransType_STATUS_get, ExecTransType_STATUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DayBookingInst_CAN_TRIGGER_BOOKING_WITHOUT_REFERENCE_TO_THE_ORDER_INITIATOR",DayBookingInst_CAN_TRIGGER_BOOKING_WITHOUT_REFERENCE_TO_THE_ORDER_INITIATOR_get, DayBookingInst_CAN_TRIGGER_BOOKING_WITHOUT_REFERENCE_TO_THE_ORDER_INITIATOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DayBookingInst_ACCUMULATE",DayBookingInst_ACCUMULATE_get, DayBookingInst_ACCUMULATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING_SPEAK_FIRST",DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING_SPEAK_FIRST_get, DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING_SPEAK_FIRST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DayBookingInst_CAN_TRIGGER_BOOKING_WITHOUT_REFERENCE_TO_THE_ORDER_INITIATOR_AUTO",DayBookingInst_CAN_TRIGGER_BOOKING_WITHOUT_REFERENCE_TO_THE_ORDER_INITIATOR_AUTO_get, DayBookingInst_CAN_TRIGGER_BOOKING_WITHOUT_REFERENCE_TO_THE_ORDER_INITIATOR_AUTO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING",DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING_get, DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FlowScheduleType_NERC_EASTERN_OFF_PEAK",FlowScheduleType_NERC_EASTERN_OFF_PEAK_get, FlowScheduleType_NERC_EASTERN_OFF_PEAK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FlowScheduleType_NERC_WESTERN_PEAK",FlowScheduleType_NERC_WESTERN_PEAK_get, FlowScheduleType_NERC_WESTERN_PEAK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FlowScheduleType_NERC_EASTERN_PEAK",FlowScheduleType_NERC_EASTERN_PEAK_get, FlowScheduleType_NERC_EASTERN_PEAK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FlowScheduleType_NERC_CALENDAR_ALL_DAYS_IN_MONTH",FlowScheduleType_NERC_CALENDAR_ALL_DAYS_IN_MONTH_get, FlowScheduleType_NERC_CALENDAR_ALL_DAYS_IN_MONTH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FlowScheduleType_NERC_WESTERN_OFF_PEAK",FlowScheduleType_NERC_WESTERN_OFF_PEAK_get, FlowScheduleType_NERC_WESTERN_OFF_PEAK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDOriginType_CROSS",MDOriginType_CROSS_get, MDOriginType_CROSS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDOriginType_OFF_BOOK",MDOriginType_OFF_BOOK_get, MDOriginType_OFF_BOOK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDOriginType_BOOK",MDOriginType_BOOK_get, MDOriginType_BOOK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryStatus_ACCEPTED_WITH_WARNINGS",CollInquiryStatus_ACCEPTED_WITH_WARNINGS_get, CollInquiryStatus_ACCEPTED_WITH_WARNINGS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryStatus_COMPLETED",CollInquiryStatus_COMPLETED_get, CollInquiryStatus_COMPLETED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryStatus_ACCEPTEDWITHWARNINGS",CollInquiryStatus_ACCEPTEDWITHWARNINGS_get, CollInquiryStatus_ACCEPTEDWITHWARNINGS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryStatus_REJECTED",CollInquiryStatus_REJECTED_get, CollInquiryStatus_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryStatus_COMPLETEDWITHWARNINGS",CollInquiryStatus_COMPLETEDWITHWARNINGS_get, CollInquiryStatus_COMPLETEDWITHWARNINGS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryStatus_ACCEPTED",CollInquiryStatus_ACCEPTED_get, CollInquiryStatus_ACCEPTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryStatus_COMPLETED_WITH_WARNINGS",CollInquiryStatus_COMPLETED_WITH_WARNINGS_get, CollInquiryStatus_COMPLETED_WITH_WARNINGS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CPProgram_3A3",CPProgram_3A3_get, CPProgram_3A3_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CPProgram_OTHER",CPProgram_OTHER_get, CPProgram_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CPProgram_3",CPProgram_3_get, CPProgram_3_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CPProgram_42",CPProgram_42_get, CPProgram_42_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CPProgram_4",CPProgram_4_get, CPProgram_4_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqType_POSITIONS",PosReqType_POSITIONS_get, PosReqType_POSITIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqType_BACKOUT_MESSAGE",PosReqType_BACKOUT_MESSAGE_get, PosReqType_BACKOUT_MESSAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqType_DELTA_POSITIONS",PosReqType_DELTA_POSITIONS_get, PosReqType_DELTA_POSITIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqType_SETTLEMENT_ACTIVITY",PosReqType_SETTLEMENT_ACTIVITY_get, PosReqType_SETTLEMENT_ACTIVITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqType_TRADES",PosReqType_TRADES_get, PosReqType_TRADES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqType_EXERCISES",PosReqType_EXERCISES_get, PosReqType_EXERCISES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqType_ASSIGNMENTS",PosReqType_ASSIGNMENTS_get, PosReqType_ASSIGNMENTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassStatusReqType_STATUS_FOR_ORDERS_FOR_AN_UNDERLYING_SECURITY",MassStatusReqType_STATUS_FOR_ORDERS_FOR_AN_UNDERLYING_SECURITY_get, MassStatusReqType_STATUS_FOR_ORDERS_FOR_AN_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITY",MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITY_get, MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassStatusReqType_STATUSSECURITYTYPE",MassStatusReqType_STATUSSECURITYTYPE_get, MassStatusReqType_STATUSSECURITYTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_CFICODE",MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_CFICODE_get, MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_CFICODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassStatusReqType_STATUSTRDSESSION",MassStatusReqType_STATUSTRDSESSION_get, MassStatusReqType_STATUSTRDSESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PARTYID",MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PARTYID_get, MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PARTYID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassStatusReqType_STATUS_FOR_SECURITY_ISSUER",MassStatusReqType_STATUS_FOR_SECURITY_ISSUER_get, MassStatusReqType_STATUS_FOR_SECURITY_ISSUER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassStatusReqType_STATUSCFICODE",MassStatusReqType_STATUSCFICODE_get, MassStatusReqType_STATUSCFICODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_TRADING_SESSION",MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_TRADING_SESSION_get, MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_TRADING_SESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassStatusReqType_STATUSUNDERLYINGSECURITY",MassStatusReqType_STATUSUNDERLYINGSECURITY_get, MassStatusReqType_STATUSUNDERLYINGSECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassStatusReqType_STATUSPARTYID",MassStatusReqType_STATUSPARTYID_get, MassStatusReqType_STATUSPARTYID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PRODUCT",MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PRODUCT_get, MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PRODUCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITYTYPE",MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITYTYPE_get, MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITYTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassStatusReqType_STATUS_FOR_ALL_ORDERS",MassStatusReqType_STATUS_FOR_ALL_ORDERS_get, MassStatusReqType_STATUS_FOR_ALL_ORDERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassStatusReqType_STATUS_FOR_ISSUER_OF_UNDERLYING_SECURITY",MassStatusReqType_STATUS_FOR_ISSUER_OF_UNDERLYING_SECURITY_get, MassStatusReqType_STATUS_FOR_ISSUER_OF_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassStatusReqType_STATUSSECURITY",MassStatusReqType_STATUSSECURITY_get, MassStatusReqType_STATUSSECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassStatusReqType_STATUSPRODUCT",MassStatusReqType_STATUSPRODUCT_get, MassStatusReqType_STATUSPRODUCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassStatusReqType_STATUSALLORDERS",MassStatusReqType_STATUSALLORDERS_get, MassStatusReqType_STATUSALLORDERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SubscriptionRequestType_DISABLE_PREVIOUS_SNAPSHOT_PLUS_UPDATE_REQUEST",SubscriptionRequestType_DISABLE_PREVIOUS_SNAPSHOT_PLUS_UPDATE_REQUEST_get, SubscriptionRequestType_DISABLE_PREVIOUS_SNAPSHOT_PLUS_UPDATE_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SubscriptionRequestType_SNAPSHOT_PLUS_UPDATES",SubscriptionRequestType_SNAPSHOT_PLUS_UPDATES_get, SubscriptionRequestType_SNAPSHOT_PLUS_UPDATES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SubscriptionRequestType_SNAPSHOTUPDATE",SubscriptionRequestType_SNAPSHOTUPDATE_get, SubscriptionRequestType_SNAPSHOTUPDATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SubscriptionRequestType_SNAPSHOT",SubscriptionRequestType_SNAPSHOT_get, SubscriptionRequestType_SNAPSHOT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SubscriptionRequestType_UNSUBSCRIBE",SubscriptionRequestType_UNSUBSCRIBE_get, SubscriptionRequestType_UNSUBSCRIBE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NewsCategory_MARKETPLACE_NEWS",NewsCategory_MARKETPLACE_NEWS_get, NewsCategory_MARKETPLACE_NEWS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NewsCategory_TECHNICAL_NEWS",NewsCategory_TECHNICAL_NEWS_get, NewsCategory_TECHNICAL_NEWS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NewsCategory_COMPANY_NEWS",NewsCategory_COMPANY_NEWS_get, NewsCategory_COMPANY_NEWS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NewsCategory_OTHER_NEWS",NewsCategory_OTHER_NEWS_get, NewsCategory_OTHER_NEWS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NewsCategory_FINANCIAL_MARKET_NEWS",NewsCategory_FINANCIAL_MARKET_NEWS_get, NewsCategory_FINANCIAL_MARKET_NEWS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQty_MEDIUM",IOIQty_MEDIUM_get, IOIQty_MEDIUM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQty_1000000000",IOIQty_1000000000_get, IOIQty_1000000000_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQty_LARGE",IOIQty_LARGE_get, IOIQty_LARGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQty_SMALL",IOIQty_SMALL_get, IOIQty_SMALL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQty_UNDISCLOSED_QUANTITY",IOIQty_UNDISCLOSED_QUANTITY_get, IOIQty_UNDISCLOSED_QUANTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplResponseError_USER_NOT_AUTHORIZED_FOR_APPLICATION",ApplResponseError_USER_NOT_AUTHORIZED_FOR_APPLICATION_get, ApplResponseError_USER_NOT_AUTHORIZED_FOR_APPLICATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplResponseError_APPLICATION_DOES_NOT_EXIST",ApplResponseError_APPLICATION_DOES_NOT_EXIST_get, ApplResponseError_APPLICATION_DOES_NOT_EXIST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplResponseError_MESSAGES_REQUESTED_ARE_NOT_AVAILABLE",ApplResponseError_MESSAGES_REQUESTED_ARE_NOT_AVAILABLE_get, 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",TriggerPriceDirection_TRIGGER_IF_THE_PRICE_OF_THE_SPECIFIED_TYPE_GOES_DOWN_TO_OR_THROUGH_THE_SPECIFIED_TRIGGER_PRICE_get, 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",TriggerPriceDirection_TRIGGER_IF_THE_PRICE_OF_THE_SPECIFIED_TYPE_GOES_UP_TO_OR_THROUGH_THE_SPECIFIED_TRIGGER_PRICE_get, 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_ADDEDLIQUIDITY",LastLiquidityInd_ADDEDLIQUIDITY_get, LastLiquidityInd_ADDEDLIQUIDITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LastLiquidityInd_LIQUIDITY_ROUTED_OUT",LastLiquidityInd_LIQUIDITY_ROUTED_OUT_get, LastLiquidityInd_LIQUIDITY_ROUTED_OUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LastLiquidityInd_LIQUIDITYROUTEDOUT",LastLiquidityInd_LIQUIDITYROUTEDOUT_get, LastLiquidityInd_LIQUIDITYROUTEDOUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LastLiquidityInd_AUCTION",LastLiquidityInd_AUCTION_get, LastLiquidityInd_AUCTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LastLiquidityInd_REMOVEDLIQUIDITY",LastLiquidityInd_REMOVEDLIQUIDITY_get, LastLiquidityInd_REMOVEDLIQUIDITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LastLiquidityInd_ADDED_LIQUIDITY",LastLiquidityInd_ADDED_LIQUIDITY_get, LastLiquidityInd_ADDED_LIQUIDITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LastLiquidityInd_REMOVED_LIQUIDITY",LastLiquidityInd_REMOVED_LIQUIDITY_get, LastLiquidityInd_REMOVED_LIQUIDITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrikePriceDeterminationMethod_STRIKE_SET_TO_AVERAGE_OF_UNDERLYING_SETTLEMENT_PRICE_ACROSS_THE_LIFE_OF_THE_OPTION",StrikePriceDeterminationMethod_STRIKE_SET_TO_AVERAGE_OF_UNDERLYING_SETTLEMENT_PRICE_ACROSS_THE_LIFE_OF_THE_OPTION_get, 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",StrikePriceDeterminationMethod_STRIKE_SET_AT_EXPIRATION_TO_UNDERLYING_OR_OTHER_VALUE_get, StrikePriceDeterminationMethod_STRIKE_SET_AT_EXPIRATION_TO_UNDERLYING_OR_OTHER_VALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrikePriceDeterminationMethod_FIXED_STRIKE",StrikePriceDeterminationMethod_FIXED_STRIKE_get, StrikePriceDeterminationMethod_FIXED_STRIKE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrikePriceDeterminationMethod_STRIKE_SET_TO_OPTIMAL_VALUE",StrikePriceDeterminationMethod_STRIKE_SET_TO_OPTIMAL_VALUE_get, StrikePriceDeterminationMethod_STRIKE_SET_TO_OPTIMAL_VALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TargetStrategy_MININIZEMARKETIMPACT",TargetStrategy_MININIZEMARKETIMPACT_get, TargetStrategy_MININIZEMARKETIMPACT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TargetStrategy_RESERVEDANDAVAILABLEFORBILATERALLYAGREEDUPONUSERDEFINEDVALUES",TargetStrategy_RESERVEDANDAVAILABLEFORBILATERALLYAGREEDUPONUSERDEFINEDVALUES_get, TargetStrategy_RESERVEDANDAVAILABLEFORBILATERALLYAGREEDUPONUSERDEFINEDVALUES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TargetStrategy_PARTICIPATE",TargetStrategy_PARTICIPATE_get, TargetStrategy_PARTICIPATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TargetStrategy_MININIZE_MARKET_IMPACT",TargetStrategy_MININIZE_MARKET_IMPACT_get, TargetStrategy_MININIZE_MARKET_IMPACT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TargetStrategy_VWAP",TargetStrategy_VWAP_get, TargetStrategy_VWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DueToRelated_NO",DueToRelated_NO_get, DueToRelated_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DueToRelated_YES",DueToRelated_YES_get, DueToRelated_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnderlyingCashType_DIFF",UnderlyingCashType_DIFF_get, UnderlyingCashType_DIFF_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnderlyingCashType_FIXED",UnderlyingCashType_FIXED_get, UnderlyingCashType_FIXED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT",CustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT_get, CustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT",CustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT_get, CustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER",CustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER_get, CustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderCapacity_ALL_OTHER",CustOrderCapacity_ALL_OTHER_get, CustOrderCapacity_ALL_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnershipType_JOINT_TRUSTEES",OwnershipType_JOINT_TRUSTEES_get, OwnershipType_JOINT_TRUSTEES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnershipType_JOINT_INVESTORS",OwnershipType_JOINT_INVESTORS_get, OwnershipType_JOINT_INVESTORS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnershipType_TENANTS_IN_COMMON",OwnershipType_TENANTS_IN_COMMON_get, OwnershipType_TENANTS_IN_COMMON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnitOfMeasure_US_DOLLARS",UnitOfMeasure_US_DOLLARS_get, UnitOfMeasure_US_DOLLARS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnitOfMeasure_TROY_OUNCES",UnitOfMeasure_TROY_OUNCES_get, UnitOfMeasure_TROY_OUNCES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnitOfMeasure_TONS",UnitOfMeasure_TONS_get, UnitOfMeasure_TONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnitOfMeasure_BILLION_CUBIC_FEET",UnitOfMeasure_BILLION_CUBIC_FEET_get, UnitOfMeasure_BILLION_CUBIC_FEET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnitOfMeasure_ONE_MILLION_BTU",UnitOfMeasure_ONE_MILLION_BTU_get, UnitOfMeasure_ONE_MILLION_BTU_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnitOfMeasure_MEGAWATT_HOURS",UnitOfMeasure_MEGAWATT_HOURS_get, UnitOfMeasure_MEGAWATT_HOURS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnitOfMeasure_MILLION_BARRELS",UnitOfMeasure_MILLION_BARRELS_get, UnitOfMeasure_MILLION_BARRELS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnitOfMeasure_GALLONS",UnitOfMeasure_GALLONS_get, UnitOfMeasure_GALLONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnitOfMeasure_BARRELS",UnitOfMeasure_BARRELS_get, UnitOfMeasure_BARRELS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnitOfMeasure_POUNDS",UnitOfMeasure_POUNDS_get, UnitOfMeasure_POUNDS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnitOfMeasure_METRIC_TONS",UnitOfMeasure_METRIC_TONS_get, UnitOfMeasure_METRIC_TONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnitOfMeasure_ALLOWANCES",UnitOfMeasure_ALLOWANCES_get, UnitOfMeasure_ALLOWANCES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnitOfMeasure_BUSHELS",UnitOfMeasure_BUSHELS_get, UnitOfMeasure_BUSHELS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecDefStatus_INVALID_DEFINITION_REQUEST",SecDefStatus_INVALID_DEFINITION_REQUEST_get, SecDefStatus_INVALID_DEFINITION_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecDefStatus_PENDING_APPROVAL",SecDefStatus_PENDING_APPROVAL_get, SecDefStatus_PENDING_APPROVAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecDefStatus_APPROVED",SecDefStatus_APPROVED_get, SecDefStatus_APPROVED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecDefStatus_UNAUTHORIZEDREQUEST",SecDefStatus_UNAUTHORIZEDREQUEST_get, SecDefStatus_UNAUTHORIZEDREQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecDefStatus_PENDINGAPPROVAL",SecDefStatus_PENDINGAPPROVAL_get, SecDefStatus_PENDINGAPPROVAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecDefStatus_UNAUTHORIZED_REQUEST",SecDefStatus_UNAUTHORIZED_REQUEST_get, SecDefStatus_UNAUTHORIZED_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecDefStatus_INVALIDDEFINITIONREQUEST",SecDefStatus_INVALIDDEFINITIONREQUEST_get, SecDefStatus_INVALIDDEFINITIONREQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecDefStatus_APPROVEDACCEPTED",SecDefStatus_APPROVEDACCEPTED_get, SecDefStatus_APPROVEDACCEPTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecDefStatus_REJECTED",SecDefStatus_REJECTED_get, SecDefStatus_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlmntTyp_WHEN_AND_IF_ISSUED",SettlmntTyp_WHEN_AND_IF_ISSUED_get, SettlmntTyp_WHEN_AND_IF_ISSUED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlmntTyp_T_PLUS_1",SettlmntTyp_T_PLUS_1_get, SettlmntTyp_T_PLUS_1_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlmntTyp_FUTURE",SettlmntTyp_FUTURE_get, SettlmntTyp_FUTURE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlmntTyp_SELLERS_OPTION",SettlmntTyp_SELLERS_OPTION_get, SettlmntTyp_SELLERS_OPTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlmntTyp_T_PLUS_2",SettlmntTyp_T_PLUS_2_get, SettlmntTyp_T_PLUS_2_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlmntTyp_T_PLUS_3",SettlmntTyp_T_PLUS_3_get, SettlmntTyp_T_PLUS_3_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlmntTyp_T_PLUS_4",SettlmntTyp_T_PLUS_4_get, SettlmntTyp_T_PLUS_4_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlmntTyp_REGULAR",SettlmntTyp_REGULAR_get, SettlmntTyp_REGULAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlmntTyp_T_PLUS_5",SettlmntTyp_T_PLUS_5_get, SettlmntTyp_T_PLUS_5_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlmntTyp_WHEN_ISSUED",SettlmntTyp_WHEN_ISSUED_get, SettlmntTyp_WHEN_ISSUED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlmntTyp_NEXT_DAY",SettlmntTyp_NEXT_DAY_get, SettlmntTyp_NEXT_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlmntTyp_CASH",SettlmntTyp_CASH_get, SettlmntTyp_CASH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradePublishIndicator_DO_NOT_PUBLISH_TRADE",TradePublishIndicator_DO_NOT_PUBLISH_TRADE_get, TradePublishIndicator_DO_NOT_PUBLISH_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradePublishIndicator_DEFERRED_PUBLICATION",TradePublishIndicator_DEFERRED_PUBLICATION_get, TradePublishIndicator_DEFERRED_PUBLICATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradePublishIndicator_PUBLISH_TRADE",TradePublishIndicator_PUBLISH_TRADE_get, TradePublishIndicator_PUBLISH_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplResponseType_MESSAGES_NOT_AVAILABLE",ApplResponseType_MESSAGES_NOT_AVAILABLE_get, ApplResponseType_MESSAGES_NOT_AVAILABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplResponseType_APPLICATION_DOES_NOT_EXIST",ApplResponseType_APPLICATION_DOES_NOT_EXIST_get, ApplResponseType_APPLICATION_DOES_NOT_EXIST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplResponseType_REQUEST_SUCCESSFULLY_PROCESSED",ApplResponseType_REQUEST_SUCCESSFULLY_PROCESSED_get, ApplResponseType_REQUEST_SUCCESSFULLY_PROCESSED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StandInstDbType_SID",StandInstDbType_SID_get, StandInstDbType_SID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StandInstDbType_DTC_SID",StandInstDbType_DTC_SID_get, StandInstDbType_DTC_SID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StandInstDbType_CUSTODIAN",StandInstDbType_CUSTODIAN_get, StandInstDbType_CUSTODIAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StandInstDbType_ALERT",StandInstDbType_ALERT_get, StandInstDbType_ALERT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StandInstDbType_ACCOUNTNET",StandInstDbType_ACCOUNTNET_get, StandInstDbType_ACCOUNTNET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StandInstDbType_A_GLOBAL_CUSTODIAN",StandInstDbType_A_GLOBAL_CUSTODIAN_get, StandInstDbType_A_GLOBAL_CUSTODIAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StandInstDbType_THOMSON_ALERT",StandInstDbType_THOMSON_ALERT_get, StandInstDbType_THOMSON_ALERT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StandInstDbType_OTHER",StandInstDbType_OTHER_get, StandInstDbType_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryStatus_CROSS_MARKET_WARNING",QuoteEntryStatus_CROSS_MARKET_WARNING_get, QuoteEntryStatus_CROSS_MARKET_WARNING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryStatus_LOCKED_MARKET_WARNING",QuoteEntryStatus_LOCKED_MARKET_WARNING_get, QuoteEntryStatus_LOCKED_MARKET_WARNING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryStatus_CANCELED_DUE_TO_CROSS_MARKET",QuoteEntryStatus_CANCELED_DUE_TO_CROSS_MARKET_get, QuoteEntryStatus_CANCELED_DUE_TO_CROSS_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryStatus_CANCELED_DUE_TO_LOCK_MARKET",QuoteEntryStatus_CANCELED_DUE_TO_LOCK_MARKET_get, QuoteEntryStatus_CANCELED_DUE_TO_LOCK_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryStatus_REJECTED",QuoteEntryStatus_REJECTED_get, QuoteEntryStatus_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryStatus_EXPIRED",QuoteEntryStatus_EXPIRED_get, QuoteEntryStatus_EXPIRED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryStatus_REMOVED_FROM_MARKET",QuoteEntryStatus_REMOVED_FROM_MARKET_get, QuoteEntryStatus_REMOVED_FROM_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryStatus_ACCEPTED",QuoteEntryStatus_ACCEPTED_get, QuoteEntryStatus_ACCEPTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryStatus_ACTIVE",QuoteEntryStatus_ACTIVE_get, QuoteEntryStatus_ACTIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerPriceType_BEST_MID",TriggerPriceType_BEST_MID_get, TriggerPriceType_BEST_MID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerPriceType_BEST_BID_OR_LAST_TRADE",TriggerPriceType_BEST_BID_OR_LAST_TRADE_get, TriggerPriceType_BEST_BID_OR_LAST_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerPriceType_BEST_BID",TriggerPriceType_BEST_BID_get, TriggerPriceType_BEST_BID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerPriceType_BEST_OFFER_OR_LAST_TRADE",TriggerPriceType_BEST_OFFER_OR_LAST_TRADE_get, TriggerPriceType_BEST_OFFER_OR_LAST_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerPriceType_BEST_OFFER",TriggerPriceType_BEST_OFFER_get, TriggerPriceType_BEST_OFFER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerPriceType_LAST_TRADE",TriggerPriceType_LAST_TRADE_get, TriggerPriceType_LAST_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SideTrdSubTyp_EXTERNAL_TRANSFER",SideTrdSubTyp_EXTERNAL_TRANSFER_get, SideTrdSubTyp_EXTERNAL_TRANSFER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SideTrdSubTyp_TRANSACTION_FROM_ASSIGNMENT",SideTrdSubTyp_TRANSACTION_FROM_ASSIGNMENT_get, SideTrdSubTyp_TRANSACTION_FROM_ASSIGNMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SideTrdSubTyp_TRANSACTION_FROM_EXERCISE",SideTrdSubTyp_TRANSACTION_FROM_EXERCISE_get, SideTrdSubTyp_TRANSACTION_FROM_EXERCISE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SideTrdSubTyp_DIFFERENTIAL_SPREAD",SideTrdSubTyp_DIFFERENTIAL_SPREAD_get, SideTrdSubTyp_DIFFERENTIAL_SPREAD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SideTrdSubTyp_ONSET_DUE_TO_AN_ALLOCATION",SideTrdSubTyp_ONSET_DUE_TO_AN_ALLOCATION_get, SideTrdSubTyp_ONSET_DUE_TO_AN_ALLOCATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SideTrdSubTyp_REJECT_FOR_SUBMITTING_TRADE",SideTrdSubTyp_REJECT_FOR_SUBMITTING_TRADE_get, SideTrdSubTyp_REJECT_FOR_SUBMITTING_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SideTrdSubTyp_CMTA",SideTrdSubTyp_CMTA_get, SideTrdSubTyp_CMTA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SideTrdSubTyp_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT",SideTrdSubTyp_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT_get, SideTrdSubTyp_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SideTrdSubTyp_INTERNAL_TRANSFER",SideTrdSubTyp_INTERNAL_TRANSFER_get, SideTrdSubTyp_INTERNAL_TRANSFER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SideTrdSubTyp_OFFSET_DUE_TO_AN_ALLOCATION",SideTrdSubTyp_OFFSET_DUE_TO_AN_ALLOCATION_get, SideTrdSubTyp_OFFSET_DUE_TO_AN_ALLOCATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SideTrdSubTyp_ADVISORY_FOR_CONTRA_SIDE",SideTrdSubTyp_ADVISORY_FOR_CONTRA_SIDE_get, SideTrdSubTyp_ADVISORY_FOR_CONTRA_SIDE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstReqRejCode_UNABLE_TO_PROCESS_REQUEST",SettlInstReqRejCode_UNABLE_TO_PROCESS_REQUEST_get, SettlInstReqRejCode_UNABLE_TO_PROCESS_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstReqRejCode_NOMATCHINGSETTLEMENTINSTRUCTIONSFOUND",SettlInstReqRejCode_NOMATCHINGSETTLEMENTINSTRUCTIONSFOUND_get, SettlInstReqRejCode_NOMATCHINGSETTLEMENTINSTRUCTIONSFOUND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstReqRejCode_UNKNOWNACCOUNT",SettlInstReqRejCode_UNKNOWNACCOUNT_get, SettlInstReqRejCode_UNKNOWNACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstReqRejCode_UNABLETOPROCESSREQUEST",SettlInstReqRejCode_UNABLETOPROCESSREQUEST_get, SettlInstReqRejCode_UNABLETOPROCESSREQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstReqRejCode_UNKNOWN_ACCOUNT",SettlInstReqRejCode_UNKNOWN_ACCOUNT_get, SettlInstReqRejCode_UNKNOWN_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstReqRejCode_NO_MATCHING_SETTLEMENT_INSTRUCTIONS_FOUND",SettlInstReqRejCode_NO_MATCHING_SETTLEMENT_INSTRUCTIONS_FOUND_get, SettlInstReqRejCode_NO_MATCHING_SETTLEMENT_INSTRUCTIONS_FOUND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstReqRejCode_OTHER",SettlInstReqRejCode_OTHER_get, SettlInstReqRejCode_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Urgency_FLASH",Urgency_FLASH_get, Urgency_FLASH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Urgency_NORMAL",Urgency_NORMAL_get, Urgency_NORMAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Urgency_BACKGROUND",Urgency_BACKGROUND_get, Urgency_BACKGROUND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnTransType_REPLACE",CollAsgnTransType_REPLACE_get, CollAsgnTransType_REPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnTransType_NEW",CollAsgnTransType_NEW_get, CollAsgnTransType_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnTransType_REVERSE",CollAsgnTransType_REVERSE_get, CollAsgnTransType_REVERSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnTransType_CANCEL",CollAsgnTransType_CANCEL_get, CollAsgnTransType_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnTransType_RELEASE",CollAsgnTransType_RELEASE_get, CollAsgnTransType_RELEASE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_FED_WIRE",PaymentMethod_FED_WIRE_get, PaymentMethod_FED_WIRE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_ACHCREDIT",PaymentMethod_ACHCREDIT_get, PaymentMethod_ACHCREDIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_TELEGRAPHICTRANSFER",PaymentMethod_TELEGRAPHICTRANSFER_get, PaymentMethod_TELEGRAPHICTRANSFER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_DIRECTDEBITBECS",PaymentMethod_DIRECTDEBITBECS_get, PaymentMethod_DIRECTDEBITBECS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_EUROCLEAR",PaymentMethod_EUROCLEAR_get, PaymentMethod_EUROCLEAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_ACH_CREDIT",PaymentMethod_ACH_CREDIT_get, PaymentMethod_ACH_CREDIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_TELEGRAPHIC_TRANSFER",PaymentMethod_TELEGRAPHIC_TRANSFER_get, PaymentMethod_TELEGRAPHIC_TRANSFER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_FEDWIRE",PaymentMethod_FEDWIRE_get, PaymentMethod_FEDWIRE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_CREDITCARD",PaymentMethod_CREDITCARD_get, PaymentMethod_CREDITCARD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_DIRECT_DEBIT",PaymentMethod_DIRECT_DEBIT_get, PaymentMethod_DIRECT_DEBIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_CREDIT_CARD",PaymentMethod_CREDIT_CARD_get, PaymentMethod_CREDIT_CARD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_CHEQUE",PaymentMethod_CHEQUE_get, PaymentMethod_CHEQUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_DIRECT_CREDIT",PaymentMethod_DIRECT_CREDIT_get, PaymentMethod_DIRECT_CREDIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_CREST",PaymentMethod_CREST_get, PaymentMethod_CREST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_HIGH_VALUE_CLEARING_SYSTEM",PaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_get, PaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_DEBITCARD",PaymentMethod_DEBITCARD_get, PaymentMethod_DEBITCARD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_CLEARSTREAM",PaymentMethod_CLEARSTREAM_get, PaymentMethod_CLEARSTREAM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_BPAY",PaymentMethod_BPAY_get, PaymentMethod_BPAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_HIGHVALUECLEARINGSYSTEMHVACS",PaymentMethod_HIGHVALUECLEARINGSYSTEMHVACS_get, PaymentMethod_HIGHVALUECLEARINGSYSTEMHVACS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_NSCC",PaymentMethod_NSCC_get, PaymentMethod_NSCC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_DEBIT_CARD",PaymentMethod_DEBIT_CARD_get, PaymentMethod_DEBIT_CARD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_ACHDEBIT",PaymentMethod_ACHDEBIT_get, PaymentMethod_ACHDEBIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_DIRECTCREDITBECS",PaymentMethod_DIRECTCREDITBECS_get, PaymentMethod_DIRECTCREDITBECS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_ACH_DEBIT",PaymentMethod_ACH_DEBIT_get, PaymentMethod_ACH_DEBIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerPriceTypeScope_LOCAL",TriggerPriceTypeScope_LOCAL_get, TriggerPriceTypeScope_LOCAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerPriceTypeScope_NONE",TriggerPriceTypeScope_NONE_get, TriggerPriceTypeScope_NONE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerPriceTypeScope_GLOBAL",TriggerPriceTypeScope_GLOBAL_get, TriggerPriceTypeScope_GLOBAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerPriceTypeScope_NATIONAL",TriggerPriceTypeScope_NATIONAL_get, TriggerPriceTypeScope_NATIONAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegLimitType_STRICT",PegLimitType_STRICT_get, PegLimitType_STRICT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegLimitType_ORWORSE",PegLimitType_ORWORSE_get, PegLimitType_ORWORSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegLimitType_OR_BETTER",PegLimitType_OR_BETTER_get, PegLimitType_OR_BETTER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegLimitType_OR_WORSE",PegLimitType_OR_WORSE_get, PegLimitType_OR_WORSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegLimitType_ORBETTER",PegLimitType_ORBETTER_get, PegLimitType_ORBETTER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_BORROW",Side_BORROW_get, Side_BORROW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_SELLPLUS",Side_SELLPLUS_get, Side_SELLPLUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_BUY_MINUS",Side_BUY_MINUS_get, Side_BUY_MINUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_BUYMIN",Side_BUYMIN_get, Side_BUYMIN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_ASDEFINED",Side_ASDEFINED_get, Side_ASDEFINED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_SUBSCRIBE",Side_SUBSCRIBE_get, Side_SUBSCRIBE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_CROSS_SHORT_EXEMPT",Side_CROSS_SHORT_EXEMPT_get, Side_CROSS_SHORT_EXEMPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_UNDISCLOSED",Side_UNDISCLOSED_get, Side_UNDISCLOSED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_SELLSHT",Side_SELLSHT_get, Side_SELLSHT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_SELLSHTEX",Side_SELLSHTEX_get, Side_SELLSHTEX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_CROSSSHORTEX",Side_CROSSSHORTEX_get, Side_CROSSSHORTEX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_CROSS",Side_CROSS_get, Side_CROSS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_SELL_SHORT_EXEMPT",Side_SELL_SHORT_EXEMPT_get, Side_SELL_SHORT_EXEMPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_UNDISC",Side_UNDISC_get, Side_UNDISC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_CROSSSHORT",Side_CROSSSHORT_get, Side_CROSSSHORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_BORROWFINANCING",Side_BORROWFINANCING_get, Side_BORROWFINANCING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_BUY",Side_BUY_get, Side_BUY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_CROSS_SHORT_EXXMPT",Side_CROSS_SHORT_EXXMPT_get, Side_CROSS_SHORT_EXXMPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_SELL",Side_SELL_get, Side_SELL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_LEND",Side_LEND_get, Side_LEND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_SELL_SHORT",Side_SELL_SHORT_get, Side_SELL_SHORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_OPPOSITE",Side_OPPOSITE_get, Side_OPPOSITE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_CROSS_SHORT",Side_CROSS_SHORT_get, Side_CROSS_SHORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_SELL_PLUS",Side_SELL_PLUS_get, Side_SELL_PLUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_REDEEM",Side_REDEEM_get, Side_REDEEM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_LENDFINANCING",Side_LENDFINANCING_get, Side_LENDFINANCING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_AS_DEFINED",Side_AS_DEFINED_get, Side_AS_DEFINED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_COMMISSIONAMT",ContAmtType_COMMISSIONAMT_get, ContAmtType_COMMISSIONAMT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_FUNDBASEDRENEWALCOMM",ContAmtType_FUNDBASEDRENEWALCOMM_get, ContAmtType_FUNDBASEDRENEWALCOMM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_INITIALCHARGEPCT",ContAmtType_INITIALCHARGEPCT_get, ContAmtType_INITIALCHARGEPCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_EXITCHARGEAMT",ContAmtType_EXITCHARGEAMT_get, ContAmtType_EXITCHARGEAMT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_EXIT_CHARGE",ContAmtType_EXIT_CHARGE_get, ContAmtType_EXIT_CHARGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_DILUTION_LEVY_AMOUNT",ContAmtType_DILUTION_LEVY_AMOUNT_get, ContAmtType_DILUTION_LEVY_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_DILUTION_LEVY_PERCENT",ContAmtType_DILUTION_LEVY_PERCENT_get, ContAmtType_DILUTION_LEVY_PERCENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_DISCOUNT_AMOUNT",ContAmtType_DISCOUNT_AMOUNT_get, ContAmtType_DISCOUNT_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_COMMISSION",ContAmtType_COMMISSION_get, ContAmtType_COMMISSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_INITIAL_CHARGE_PERCENT",ContAmtType_INITIAL_CHARGE_PERCENT_get, ContAmtType_INITIAL_CHARGE_PERCENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_DILUTIONLEVYAMT",ContAmtType_DILUTIONLEVYAMT_get, ContAmtType_DILUTIONLEVYAMT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_DILUTION_LEVY",ContAmtType_DILUTION_LEVY_get, ContAmtType_DILUTION_LEVY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_COMMISSION_AMOUNT",ContAmtType_COMMISSION_AMOUNT_get, ContAmtType_COMMISSION_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_NET_SETTLEMENT_AMOUNT",ContAmtType_NET_SETTLEMENT_AMOUNT_get, ContAmtType_NET_SETTLEMENT_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_EXITCHARGEPCT",ContAmtType_EXITCHARGEPCT_get, ContAmtType_EXITCHARGEPCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_COMMISSIONPCT",ContAmtType_COMMISSIONPCT_get, ContAmtType_COMMISSIONPCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_FUND_BASED_RENEWAL_COMMISSION",ContAmtType_FUND_BASED_RENEWAL_COMMISSION_get, ContAmtType_FUND_BASED_RENEWAL_COMMISSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_DISCOUNT",ContAmtType_DISCOUNT_get, ContAmtType_DISCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_FUNDBASEDRENEWALCOMMAMTORD",ContAmtType_FUNDBASEDRENEWALCOMMAMTORD_get, ContAmtType_FUNDBASEDRENEWALCOMMAMTORD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_DISCOUNTPCT",ContAmtType_DISCOUNTPCT_get, ContAmtType_DISCOUNTPCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_13",ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_13_get, ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_13_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_EXIT_CHARGE_AMOUNT",ContAmtType_EXIT_CHARGE_AMOUNT_get, ContAmtType_EXIT_CHARGE_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_INITIAL_CHARGE",ContAmtType_INITIAL_CHARGE_get, ContAmtType_INITIAL_CHARGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_EXIT_CHARGE_PERCENT",ContAmtType_EXIT_CHARGE_PERCENT_get, ContAmtType_EXIT_CHARGE_PERCENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_DISCOUNT_PERCENT",ContAmtType_DISCOUNT_PERCENT_get, ContAmtType_DISCOUNT_PERCENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_INITIALCHARGEAMT",ContAmtType_INITIALCHARGEAMT_get, ContAmtType_INITIALCHARGEAMT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_DILUTIONLEVYPCT",ContAmtType_DILUTIONLEVYPCT_get, ContAmtType_DILUTIONLEVYPCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_14",ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_14_get, ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_14_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_FUNDBASEDRENEWALCOMMAMTPROJ",ContAmtType_FUNDBASEDRENEWALCOMMAMTPROJ_get, ContAmtType_FUNDBASEDRENEWALCOMMAMTPROJ_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_NETSETTLEMENTAMOUNT",ContAmtType_NETSETTLEMENTAMOUNT_get, ContAmtType_NETSETTLEMENTAMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_PROJECTEDFUNDVALUE",ContAmtType_PROJECTEDFUNDVALUE_get, ContAmtType_PROJECTEDFUNDVALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_DISCOUNTAMT",ContAmtType_DISCOUNTAMT_get, ContAmtType_DISCOUNTAMT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_FUND_BASED_RENEWAL_COMMISSION_PERCENT",ContAmtType_FUND_BASED_RENEWAL_COMMISSION_PERCENT_get, ContAmtType_FUND_BASED_RENEWAL_COMMISSION_PERCENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_COMMISSION_PERCENT",ContAmtType_COMMISSION_PERCENT_get, ContAmtType_COMMISSION_PERCENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_PROJECTED_FUND_VALUE",ContAmtType_PROJECTED_FUND_VALUE_get, ContAmtType_PROJECTED_FUND_VALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_INITIAL_CHARGE_AMOUNT",ContAmtType_INITIAL_CHARGE_AMOUNT_get, ContAmtType_INITIAL_CHARGE_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderCategory_IMPLIED_ORDER",OrderCategory_IMPLIED_ORDER_get, OrderCategory_IMPLIED_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderCategory_STREAMING_PRICE",OrderCategory_STREAMING_PRICE_get, OrderCategory_STREAMING_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderCategory_QUOTE_REQUEST",OrderCategory_QUOTE_REQUEST_get, OrderCategory_QUOTE_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderCategory_CROSS_ORDER",OrderCategory_CROSS_ORDER_get, OrderCategory_CROSS_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderCategory_MULTILEG_ORDER",OrderCategory_MULTILEG_ORDER_get, OrderCategory_MULTILEG_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderCategory_PRIVATELY_NEGOTIATED_TRADE",OrderCategory_PRIVATELY_NEGOTIATED_TRADE_get, OrderCategory_PRIVATELY_NEGOTIATED_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderCategory_QUOTE",OrderCategory_QUOTE_get, OrderCategory_QUOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderCategory_ORDER",OrderCategory_ORDER_get, OrderCategory_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderCategory_LINKED_ORDER",OrderCategory_LINKED_ORDER_get, OrderCategory_LINKED_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AdvTransType_REPLACE",AdvTransType_REPLACE_get, AdvTransType_REPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AdvTransType_NEW",AdvTransType_NEW_get, AdvTransType_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AdvTransType_ADVCANCEL",AdvTransType_ADVCANCEL_get, AdvTransType_ADVCANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AdvTransType_ADVREPLACE",AdvTransType_ADVREPLACE_get, AdvTransType_ADVREPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AdvTransType_ADVNEW",AdvTransType_ADVNEW_get, AdvTransType_ADVNEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AdvTransType_CANCEL",AdvTransType_CANCEL_get, AdvTransType_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PublishTrdIndicator_NO",PublishTrdIndicator_NO_get, PublishTrdIndicator_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PublishTrdIndicator_YES",PublishTrdIndicator_YES_get, PublishTrdIndicator_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityResponseType_ACCPTSECPROPREV",SecurityResponseType_ACCPTSECPROPREV_get, SecurityResponseType_ACCPTSECPROPREV_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityResponseType_SECLISTTYPESRET",SecurityResponseType_SECLISTTYPESRET_get, SecurityResponseType_SECLISTTYPESRET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityResponseType_LIST_OF_SECURITIES_RETURNED_PER_REQUEST",SecurityResponseType_LIST_OF_SECURITIES_RETURNED_PER_REQUEST_get, SecurityResponseType_LIST_OF_SECURITIES_RETURNED_PER_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityResponseType_LIST_OF_SECURITY_TYPES_RETURNED_PER_REQUEST",SecurityResponseType_LIST_OF_SECURITY_TYPES_RETURNED_PER_REQUEST_get, 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",SecurityResponseType_ACCEPT_SECURITY_PROPOSAL_WITH_REVISIONS_AS_INDICATED_IN_THE_MESSAGE_get, SecurityResponseType_ACCEPT_SECURITY_PROPOSAL_WITH_REVISIONS_AS_INDICATED_IN_THE_MESSAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityResponseType_ACCEPT_SECURITY_PROPOSAL_AS_IS",SecurityResponseType_ACCEPT_SECURITY_PROPOSAL_AS_IS_get, SecurityResponseType_ACCEPT_SECURITY_PROPOSAL_AS_IS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityResponseType_ACCPTSECPROP",SecurityResponseType_ACCPTSECPROP_get, SecurityResponseType_ACCPTSECPROP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityResponseType_REJECT_SECURITY_PROPOSAL",SecurityResponseType_REJECT_SECURITY_PROPOSAL_get, SecurityResponseType_REJECT_SECURITY_PROPOSAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityResponseType_SECLISTRET",SecurityResponseType_SECLISTRET_get, SecurityResponseType_SECLISTRET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityResponseType_REJSECPROP",SecurityResponseType_REJSECPROP_get, SecurityResponseType_REJSECPROP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityResponseType_CAN_NOT_MATCH_SELECTION_CRITERIA",SecurityResponseType_CAN_NOT_MATCH_SELECTION_CRITERIA_get, SecurityResponseType_CAN_NOT_MATCH_SELECTION_CRITERIA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityResponseType_CANNOT_MATCH_SELECTION_CRITERIA",SecurityResponseType_CANNOT_MATCH_SELECTION_CRITERIA_get, SecurityResponseType_CANNOT_MATCH_SELECTION_CRITERIA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityResponseType_NOMATCH",SecurityResponseType_NOMATCH_get, SecurityResponseType_NOMATCH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionStatus_PASSWORD_EXPIRED",SessionStatus_PASSWORD_EXPIRED_get, SessionStatus_PASSWORD_EXPIRED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionStatus_SESSION_LOGOUT_COMPLETE",SessionStatus_SESSION_LOGOUT_COMPLETE_get, SessionStatus_SESSION_LOGOUT_COMPLETE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionStatus_INVALID_USERNAME_OR_PASSWORD",SessionStatus_INVALID_USERNAME_OR_PASSWORD_get, SessionStatus_INVALID_USERNAME_OR_PASSWORD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionStatus_SESSION_ACTIVE",SessionStatus_SESSION_ACTIVE_get, SessionStatus_SESSION_ACTIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionStatus_SESSION_PASSWORD_CHANGED",SessionStatus_SESSION_PASSWORD_CHANGED_get, SessionStatus_SESSION_PASSWORD_CHANGED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionStatus_ACCOUNT_LOCKED",SessionStatus_ACCOUNT_LOCKED_get, SessionStatus_ACCOUNT_LOCKED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionStatus_LOGONS_ARE_NOT_ALLOWED_AT_THIS_TIME",SessionStatus_LOGONS_ARE_NOT_ALLOWED_AT_THIS_TIME_get, SessionStatus_LOGONS_ARE_NOT_ALLOWED_AT_THIS_TIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionStatus_SESSION_PASSWORD_DUE_TO_EXPIRE",SessionStatus_SESSION_PASSWORD_DUE_TO_EXPIRE_get, SessionStatus_SESSION_PASSWORD_DUE_TO_EXPIRE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionStatus_NEW_SESSION_PASSWORD_DOES_NOT_COMPLY_WITH_POLICY",SessionStatus_NEW_SESSION_PASSWORD_DOES_NOT_COMPLY_WITH_POLICY_get, SessionStatus_NEW_SESSION_PASSWORD_DOES_NOT_COMPLY_WITH_POLICY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocAccountType_JBO",AllocAccountType_JBO_get, AllocAccountType_JBO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocAccountType_HOUSE_TRADER",AllocAccountType_HOUSE_TRADER_get, AllocAccountType_HOUSE_TRADER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS",AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_get, AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocAccountType_FLOOR_TRADER",AllocAccountType_FLOOR_TRADER_get, AllocAccountType_FLOOR_TRADER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocAccountType_ACCOUNTISHOUSETRADERANDISCROSSMARGINED",AllocAccountType_ACCOUNTISHOUSETRADERANDISCROSSMARGINED_get, AllocAccountType_ACCOUNTISHOUSETRADERANDISCROSSMARGINED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocAccountType_ACCOUNTISCARRIEDONCUSTOMERSIDEOFBOOKS",AllocAccountType_ACCOUNTISCARRIEDONCUSTOMERSIDEOFBOOKS_get, AllocAccountType_ACCOUNTISCARRIEDONCUSTOMERSIDEOFBOOKS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocAccountType_JOINT_BACK_OFFICE_ACCOUNT",AllocAccountType_JOINT_BACK_OFFICE_ACCOUNT_get, AllocAccountType_JOINT_BACK_OFFICE_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocAccountType_ACCOUNTISCARRIEDONNONCUSTOMERSIDEOFBOOKSANDISCROSSMARGINED",AllocAccountType_ACCOUNTISCARRIEDONNONCUSTOMERSIDEOFBOOKSANDISCROSSMARGINED_get, AllocAccountType_ACCOUNTISCARRIEDONNONCUSTOMERSIDEOFBOOKSANDISCROSSMARGINED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocAccountType_HOUSETRADER",AllocAccountType_HOUSETRADER_get, AllocAccountType_HOUSETRADER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocAccountType_FLOORTRADER",AllocAccountType_FLOORTRADER_get, AllocAccountType_FLOORTRADER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED",AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED_get, AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocAccountType_ACCOUNT_IS_CARRIED_PN_CUSTOMER_SIDE_OF_BOOKS",AllocAccountType_ACCOUNT_IS_CARRIED_PN_CUSTOMER_SIDE_OF_BOOKS_get, AllocAccountType_ACCOUNT_IS_CARRIED_PN_CUSTOMER_SIDE_OF_BOOKS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocAccountType_ACCOUNTISCARRIEDONNONCUSTOMERSIDEOFBOOKS",AllocAccountType_ACCOUNTISCARRIEDONNONCUSTOMERSIDEOFBOOKS_get, AllocAccountType_ACCOUNTISCARRIEDONNONCUSTOMERSIDEOFBOOKS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocAccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED",AllocAccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED_get, AllocAccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocTransType_REPLACE",AllocTransType_REPLACE_get, AllocTransType_REPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocTransType_NEW",AllocTransType_NEW_get, AllocTransType_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocTransType_CALCULATED",AllocTransType_CALCULATED_get, AllocTransType_CALCULATED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocTransType_PRELIMINARY",AllocTransType_PRELIMINARY_get, AllocTransType_PRELIMINARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocTransType_CALCULATEDWITHOUTPRELIMINARY",AllocTransType_CALCULATEDWITHOUTPRELIMINARY_get, AllocTransType_CALCULATEDWITHOUTPRELIMINARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocTransType_CANCEL",AllocTransType_CANCEL_get, AllocTransType_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocTransType_REVERSAL",AllocTransType_REVERSAL_get, AllocTransType_REVERSAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocTransType_CALCULATED_WITHOUT_PRELIMINARY",AllocTransType_CALCULATED_WITHOUT_PRELIMINARY_get, AllocTransType_CALCULATED_WITHOUT_PRELIMINARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExpirationQtyType_DIFFERENCE",ExpirationQtyType_DIFFERENCE_get, ExpirationQtyType_DIFFERENCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExpirationQtyType_FINAL_WILL_BE_EXERCISED",ExpirationQtyType_FINAL_WILL_BE_EXERCISED_get, ExpirationQtyType_FINAL_WILL_BE_EXERCISED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExpirationQtyType_NON_AUTO_EXERCISE",ExpirationQtyType_NON_AUTO_EXERCISE_get, ExpirationQtyType_NON_AUTO_EXERCISE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExpirationQtyType_CONTRARY_INTENTION",ExpirationQtyType_CONTRARY_INTENTION_get, ExpirationQtyType_CONTRARY_INTENTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExpirationQtyType_AUTO_EXERCISE",ExpirationQtyType_AUTO_EXERCISE_get, ExpirationQtyType_AUTO_EXERCISE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocHandlInst_FORWARDMATCH",AllocHandlInst_FORWARDMATCH_get, AllocHandlInst_FORWARDMATCH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocHandlInst_FORWARD_AND_MATCH",AllocHandlInst_FORWARD_AND_MATCH_get, AllocHandlInst_FORWARD_AND_MATCH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocHandlInst_FORWARD",AllocHandlInst_FORWARD_get, AllocHandlInst_FORWARD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocHandlInst_MATCH",AllocHandlInst_MATCH_get, AllocHandlInst_MATCH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestStatus_COMPLETED",TradeRequestStatus_COMPLETED_get, TradeRequestStatus_COMPLETED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestStatus_REJECTED",TradeRequestStatus_REJECTED_get, TradeRequestStatus_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestStatus_ACCEPTED",TradeRequestStatus_ACCEPTED_get, TradeRequestStatus_ACCEPTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PreallocMethod_DO_NOT_PRO_RATA_DISCUSS_FIRST",PreallocMethod_DO_NOT_PRO_RATA_DISCUSS_FIRST_get, PreallocMethod_DO_NOT_PRO_RATA_DISCUSS_FIRST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PreallocMethod_PRO_RATA",PreallocMethod_PRO_RATA_get, PreallocMethod_PRO_RATA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PreallocMethod_DO_NOT_PRORATA_DISCUSS_FIRST",PreallocMethod_DO_NOT_PRORATA_DISCUSS_FIRST_get, PreallocMethod_DO_NOT_PRORATA_DISCUSS_FIRST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PreallocMethod_DO_NOT_PRO_RATA",PreallocMethod_DO_NOT_PRO_RATA_get, PreallocMethod_DO_NOT_PRO_RATA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PreallocMethod_PRORATA",PreallocMethod_PRORATA_get, PreallocMethod_PRORATA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_ROTHIRANONPROTOTYPEUS",TaxAdvantageType_ROTHIRANONPROTOTYPEUS_get, TaxAdvantageType_ROTHIRANONPROTOTYPEUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_INDIVIDUALRETIREMENTACCOUNTROLLOVERUS",TaxAdvantageType_INDIVIDUALRETIREMENTACCOUNTROLLOVERUS_get, TaxAdvantageType_INDIVIDUALRETIREMENTACCOUNTROLLOVERUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_PROFITSHARINGPLANUS",TaxAdvantageType_PROFITSHARINGPLANUS_get, TaxAdvantageType_PROFITSHARINGPLANUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_SELF_DIRECTED_IRA",TaxAdvantageType_SELF_DIRECTED_IRA_get, TaxAdvantageType_SELF_DIRECTED_IRA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_401",TaxAdvantageType_401_get, TaxAdvantageType_401_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_EMPLOYER_11",TaxAdvantageType_EMPLOYER_11_get, TaxAdvantageType_EMPLOYER_11_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_457US",TaxAdvantageType_457US_get, TaxAdvantageType_457US_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_EMPLOYER_12",TaxAdvantageType_EMPLOYER_12_get, TaxAdvantageType_EMPLOYER_12_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_MINI_CASH_ISA",TaxAdvantageType_MINI_CASH_ISA_get, TaxAdvantageType_MINI_CASH_ISA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_MINI_STOCKS_AND_SHARES_ISA",TaxAdvantageType_MINI_STOCKS_AND_SHARES_ISA_get, TaxAdvantageType_MINI_STOCKS_AND_SHARES_ISA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_ROTH_CONVERSION_IRA_26",TaxAdvantageType_ROTH_CONVERSION_IRA_26_get, TaxAdvantageType_ROTH_CONVERSION_IRA_26_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_EMPLOYEE",TaxAdvantageType_EMPLOYEE_get, TaxAdvantageType_EMPLOYEE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_SELFDIRECTEDIRAUS",TaxAdvantageType_SELFDIRECTEDIRAUS_get, TaxAdvantageType_SELFDIRECTEDIRAUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_403",TaxAdvantageType_403_get, TaxAdvantageType_403_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_NON_FUND_PROTOTYPE_IRA",TaxAdvantageType_NON_FUND_PROTOTYPE_IRA_get, TaxAdvantageType_NON_FUND_PROTOTYPE_IRA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_NONFUNDPROTOTYPEIRAUS",TaxAdvantageType_NONFUNDPROTOTYPEIRAUS_get, TaxAdvantageType_NONFUNDPROTOTYPEIRAUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_ROTH_CONVERSION_IRA_27",TaxAdvantageType_ROTH_CONVERSION_IRA_27_get, TaxAdvantageType_ROTH_CONVERSION_IRA_27_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_ROTHCONVERSIONIRANONPROTOTYPEUS",TaxAdvantageType_ROTHCONVERSIONIRANONPROTOTYPEUS_get, TaxAdvantageType_ROTHCONVERSIONIRANONPROTOTYPEUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_MINI_INSURANCE_ISA",TaxAdvantageType_MINI_INSURANCE_ISA_get, TaxAdvantageType_MINI_INSURANCE_ISA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_ROTHCONVERSIONIRAFUNDPROTOTYPEUS",TaxAdvantageType_ROTHCONVERSIONIRAFUNDPROTOTYPEUS_get, TaxAdvantageType_ROTHCONVERSIONIRAFUNDPROTOTYPEUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_EDUCATIONIRAFUNDPROTOTYPEUS",TaxAdvantageType_EDUCATIONIRAFUNDPROTOTYPEUS_get, TaxAdvantageType_EDUCATIONIRAFUNDPROTOTYPEUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_MAXIISAUK",TaxAdvantageType_MAXIISAUK_get, TaxAdvantageType_MAXIISAUK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_ROLLOVER",TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_ROLLOVER_get, TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_ROLLOVER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_NONFUNDQUALIFIEDPLANUS",TaxAdvantageType_NONFUNDQUALIFIEDPLANUS_get, TaxAdvantageType_NONFUNDQUALIFIEDPLANUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_EMPLOYER_CURRENT_YEAR",TaxAdvantageType_EMPLOYER_CURRENT_YEAR_get, TaxAdvantageType_EMPLOYER_CURRENT_YEAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_PRIORYEARPAYMENTUS",TaxAdvantageType_PRIORYEARPAYMENTUS_get, TaxAdvantageType_PRIORYEARPAYMENTUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_TESSAUK",TaxAdvantageType_TESSAUK_get, TaxAdvantageType_TESSAUK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_CURRENTYEARPAYMENTUS",TaxAdvantageType_CURRENTYEARPAYMENTUS_get, TaxAdvantageType_CURRENTYEARPAYMENTUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_EDUCATIONIRANONPROTOTYPEUS",TaxAdvantageType_EDUCATIONIRANONPROTOTYPEUS_get, TaxAdvantageType_EDUCATIONIRANONPROTOTYPEUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_INDIVIDUALRETIREMENTACCOUNTUS",TaxAdvantageType_INDIVIDUALRETIREMENTACCOUNTUS_get, TaxAdvantageType_INDIVIDUALRETIREMENTACCOUNTUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_KEOGHUS",TaxAdvantageType_KEOGHUS_get, TaxAdvantageType_KEOGHUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_EDUCATION_IRA_28",TaxAdvantageType_EDUCATION_IRA_28_get, TaxAdvantageType_EDUCATION_IRA_28_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_PROFIT_SHARING_PLAN",TaxAdvantageType_PROFIT_SHARING_PLAN_get, TaxAdvantageType_PROFIT_SHARING_PLAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_NON_FUND_QUALIFIED_PLAN",TaxAdvantageType_NON_FUND_QUALIFIED_PLAN_get, TaxAdvantageType_NON_FUND_QUALIFIED_PLAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_ROTHIRAFUNDPROTOTYPEUS",TaxAdvantageType_ROTHIRAFUNDPROTOTYPEUS_get, TaxAdvantageType_ROTHIRAFUNDPROTOTYPEUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_EDUCATION_IRA_29",TaxAdvantageType_EDUCATION_IRA_29_get, TaxAdvantageType_EDUCATION_IRA_29_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_EMPLOYEE_10",TaxAdvantageType_EMPLOYEE_10_get, TaxAdvantageType_EMPLOYEE_10_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_EMPLOYEE_9",TaxAdvantageType_EMPLOYEE_9_get, TaxAdvantageType_EMPLOYEE_9_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_EMPLOYEE_CURRENT_YEAR",TaxAdvantageType_EMPLOYEE_CURRENT_YEAR_get, TaxAdvantageType_EMPLOYEE_CURRENT_YEAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_MAXI_ISA",TaxAdvantageType_MAXI_ISA_get, TaxAdvantageType_MAXI_ISA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_MINIINSURANCEISAUK",TaxAdvantageType_MINIINSURANCEISAUK_get, TaxAdvantageType_MINIINSURANCEISAUK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_PRIOR_YEAR_PAYMENT",TaxAdvantageType_PRIOR_YEAR_PAYMENT_get, TaxAdvantageType_PRIOR_YEAR_PAYMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_DEFINED_CONTRIBUTION_PLAN",TaxAdvantageType_DEFINED_CONTRIBUTION_PLAN_get, TaxAdvantageType_DEFINED_CONTRIBUTION_PLAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_401K",TaxAdvantageType_401K_get, TaxAdvantageType_401K_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_403BUS",TaxAdvantageType_403BUS_get, TaxAdvantageType_403BUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_MINICASHISAUK",TaxAdvantageType_MINICASHISAUK_get, TaxAdvantageType_MINICASHISAUK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_ROTH_IRA_24",TaxAdvantageType_ROTH_IRA_24_get, TaxAdvantageType_ROTH_IRA_24_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_MINISTOCKSANDSHARESISAUK",TaxAdvantageType_MINISTOCKSANDSHARESISAUK_get, TaxAdvantageType_MINISTOCKSANDSHARESISAUK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_OTHER",TaxAdvantageType_OTHER_get, TaxAdvantageType_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_EMPLOYERCURRENTYEARUS",TaxAdvantageType_EMPLOYERCURRENTYEARUS_get, TaxAdvantageType_EMPLOYERCURRENTYEARUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_ASSET_TRANSFER",TaxAdvantageType_ASSET_TRANSFER_get, TaxAdvantageType_ASSET_TRANSFER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_ROTH_IRA_25",TaxAdvantageType_ROTH_IRA_25_get, TaxAdvantageType_ROTH_IRA_25_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_KEOGH",TaxAdvantageType_KEOGH_get, TaxAdvantageType_KEOGH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_DEFINEDCONTRIBUTIONPLANUS",TaxAdvantageType_DEFINEDCONTRIBUTIONPLANUS_get, TaxAdvantageType_DEFINEDCONTRIBUTIONPLANUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_401KUS",TaxAdvantageType_401KUS_get, TaxAdvantageType_401KUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_TESSA",TaxAdvantageType_TESSA_get, TaxAdvantageType_TESSA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_NONE_NOT_APPLICABLE",TaxAdvantageType_NONE_NOT_APPLICABLE_get, TaxAdvantageType_NONE_NOT_APPLICABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_NONE",TaxAdvantageType_NONE_get, TaxAdvantageType_NONE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_457",TaxAdvantageType_457_get, TaxAdvantageType_457_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_EMPLOYEEPRIORYEARUS",TaxAdvantageType_EMPLOYEEPRIORYEARUS_get, TaxAdvantageType_EMPLOYEEPRIORYEARUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_EMPLOYERPRIORYEARUS",TaxAdvantageType_EMPLOYERPRIORYEARUS_get, TaxAdvantageType_EMPLOYERPRIORYEARUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_EMPLOYER",TaxAdvantageType_EMPLOYER_get, TaxAdvantageType_EMPLOYER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_EMPLOYEECURRENTYEARUS",TaxAdvantageType_EMPLOYEECURRENTYEARUS_get, TaxAdvantageType_EMPLOYEECURRENTYEARUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_16",TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_16_get, TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_16_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT",TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_get, TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_17",TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_17_get, TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_17_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_CURRENT_YEAR_PAYMENT",TaxAdvantageType_CURRENT_YEAR_PAYMENT_get, TaxAdvantageType_CURRENT_YEAR_PAYMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_ASSETTRANSFERUS",TaxAdvantageType_ASSETTRANSFERUS_get, TaxAdvantageType_ASSETTRANSFERUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MessageEncoding_EUC_JP",MessageEncoding_EUC_JP_get, MessageEncoding_EUC_JP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MessageEncoding_SHIFT_JIS",MessageEncoding_SHIFT_JIS_get, MessageEncoding_SHIFT_JIS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MessageEncoding_UTF_8",MessageEncoding_UTF_8_get, MessageEncoding_UTF_8_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MessageEncoding_ISO_2022_JP",MessageEncoding_ISO_2022_JP_get, MessageEncoding_ISO_2022_JP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeInForce_GOOD_TILL_CROSSING",TimeInForce_GOOD_TILL_CROSSING_get, TimeInForce_GOOD_TILL_CROSSING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeInForce_FILL_OR_KILL",TimeInForce_FILL_OR_KILL_get, TimeInForce_FILL_OR_KILL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeInForce_GOOD_TILL_DATE",TimeInForce_GOOD_TILL_DATE_get, TimeInForce_GOOD_TILL_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeInForce_ATTHEOPENING",TimeInForce_ATTHEOPENING_get, TimeInForce_ATTHEOPENING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeInForce_FILLORKILL",TimeInForce_FILLORKILL_get, TimeInForce_FILLORKILL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeInForce_GOODTILLDATE",TimeInForce_GOODTILLDATE_get, TimeInForce_GOODTILLDATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeInForce_GOODTILLCANCEL",TimeInForce_GOODTILLCANCEL_get, TimeInForce_GOODTILLCANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeInForce_ATTHECLOSE",TimeInForce_ATTHECLOSE_get, TimeInForce_ATTHECLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeInForce_GOOD_TILL_CANCEL",TimeInForce_GOOD_TILL_CANCEL_get, TimeInForce_GOOD_TILL_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeInForce_DAY",TimeInForce_DAY_get, TimeInForce_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeInForce_AT_CROSSING",TimeInForce_AT_CROSSING_get, TimeInForce_AT_CROSSING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeInForce_IMMEDIATEORCANCEL",TimeInForce_IMMEDIATEORCANCEL_get, TimeInForce_IMMEDIATEORCANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeInForce_IMMEDIATE_OR_CANCEL",TimeInForce_IMMEDIATE_OR_CANCEL_get, TimeInForce_IMMEDIATE_OR_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeInForce_GOODTILLCROSSING",TimeInForce_GOODTILLCROSSING_get, TimeInForce_GOODTILLCROSSING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeInForce_GOOD_THROUGH_CROSSING",TimeInForce_GOOD_THROUGH_CROSSING_get, TimeInForce_GOOD_THROUGH_CROSSING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeInForce_AT_THE_CLOSE",TimeInForce_AT_THE_CLOSE_get, TimeInForce_AT_THE_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeInForce_AT_THE_OPENING",TimeInForce_AT_THE_OPENING_get, TimeInForce_AT_THE_OPENING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_AON",IOIQualifier_AON_get, IOIQualifier_AON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_THROUGH_THE_DAY",IOIQualifier_THROUGH_THE_DAY_get, IOIQualifier_THROUGH_THE_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_INDIDCATION",IOIQualifier_INDIDCATION_get, IOIQualifier_INDIDCATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_MOC",IOIQualifier_MOC_get, IOIQualifier_MOC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_READYTRADE",IOIQualifier_READYTRADE_get, IOIQualifier_READYTRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_ATMID",IOIQualifier_ATMID_get, IOIQualifier_ATMID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_INDWRKAWAY",IOIQualifier_INDWRKAWAY_get, IOIQualifier_INDWRKAWAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_AT_THE_MARKET",IOIQualifier_AT_THE_MARKET_get, IOIQualifier_AT_THE_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_AT_THE_MIDPOINT",IOIQualifier_AT_THE_MIDPOINT_get, IOIQualifier_AT_THE_MIDPOINT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_CROSSING_OPPORTUNITY",IOIQualifier_CROSSING_OPPORTUNITY_get, IOIQualifier_CROSSING_OPPORTUNITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_CURRENT_QUOTE",IOIQualifier_CURRENT_QUOTE_get, IOIQualifier_CURRENT_QUOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_IN_TOUCH_WITH",IOIQualifier_IN_TOUCH_WITH_get, IOIQualifier_IN_TOUCH_WITH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_ALL_OR_NONE",IOIQualifier_ALL_OR_NONE_get, IOIQualifier_ALL_OR_NONE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_THROUGHDAY",IOIQualifier_THROUGHDAY_get, IOIQualifier_THROUGHDAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_TAKING_A_POSITION",IOIQualifier_TAKING_A_POSITION_get, IOIQualifier_TAKING_A_POSITION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_AT_THE_OPEN",IOIQualifier_AT_THE_OPEN_get, IOIQualifier_AT_THE_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_TAKEPOSITION",IOIQualifier_TAKEPOSITION_get, IOIQualifier_TAKEPOSITION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_PORTFOLIO_SHOW_N",IOIQualifier_PORTFOLIO_SHOW_N_get, IOIQualifier_PORTFOLIO_SHOW_N_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_INTOUCH",IOIQualifier_INTOUCH_get, IOIQualifier_INTOUCH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_MOREBEHIND",IOIQualifier_MOREBEHIND_get, IOIQualifier_MOREBEHIND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_ATMARKET",IOIQualifier_ATMARKET_get, IOIQualifier_ATMARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_CROSSOPP",IOIQualifier_CROSSOPP_get, IOIQualifier_CROSSOPP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_PREOPEN",IOIQualifier_PREOPEN_get, IOIQualifier_PREOPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_ATCLOSE",IOIQualifier_ATCLOSE_get, IOIQualifier_ATCLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_MARKET_ON_CLOSE",IOIQualifier_MARKET_ON_CLOSE_get, IOIQualifier_MARKET_ON_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_VERSUS",IOIQualifier_VERSUS_get, IOIQualifier_VERSUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_LIMIT",IOIQualifier_LIMIT_get, IOIQualifier_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_PORTFOLIO_SHOWN",IOIQualifier_PORTFOLIO_SHOWN_get, IOIQualifier_PORTFOLIO_SHOWN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_READY_TO_TRADE",IOIQualifier_READY_TO_TRADE_get, IOIQualifier_READY_TO_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_PRE_OPEN",IOIQualifier_PRE_OPEN_get, IOIQualifier_PRE_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_INDICATION",IOIQualifier_INDICATION_get, IOIQualifier_INDICATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_MORE_BEHIND",IOIQualifier_MORE_BEHIND_get, IOIQualifier_MORE_BEHIND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_ATOPEN",IOIQualifier_ATOPEN_get, IOIQualifier_ATOPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_VWAP",IOIQualifier_VWAP_get, IOIQualifier_VWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_PORTSHOW",IOIQualifier_PORTSHOW_get, IOIQualifier_PORTSHOW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_AT_THE_CLOSE",IOIQualifier_AT_THE_CLOSE_get, IOIQualifier_AT_THE_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrikePriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_UNDERLYING_PRICE_IS_IN_THE_MONEY",StrikePriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_UNDERLYING_PRICE_IS_IN_THE_MONEY_get, 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",StrikePriceBoundaryMethod_GREATER_THAN_UNDERLYING_IS_IN_THE_MONEY_get, 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",StrikePriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_THE_UNDERLYING_PRICE_IS_IN_THE_MONEY_get, 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",StrikePriceBoundaryMethod_LESS_THAN_UNDERLYING_PRICE_IS_IN_THE_MONEY_get, 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",StrikePriceBoundaryMethod_EQUAL_TO_THE_UNDERLYING_PRICE_IS_IN_THE_MONEY_get, StrikePriceBoundaryMethod_EQUAL_TO_THE_UNDERLYING_PRICE_IS_IN_THE_MONEY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_CONVERSION",MiscFeeType_CONVERSION_get, MiscFeeType_CONVERSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_CONSUMPTION_TAX",MiscFeeType_CONSUMPTION_TAX_get, MiscFeeType_CONSUMPTION_TAX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_LOCAL_COMMISSION",MiscFeeType_LOCAL_COMMISSION_get, MiscFeeType_LOCAL_COMMISSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_TAX",MiscFeeType_TAX_get, MiscFeeType_TAX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_LOCALCOMM",MiscFeeType_LOCALCOMM_get, MiscFeeType_LOCALCOMM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_MARKUP",MiscFeeType_MARKUP_get, MiscFeeType_MARKUP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_SECURITY_LENDING",MiscFeeType_SECURITY_LENDING_get, MiscFeeType_SECURITY_LENDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_PER_TRANSACTION",MiscFeeType_PER_TRANSACTION_get, MiscFeeType_PER_TRANSACTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_REGULATORY",MiscFeeType_REGULATORY_get, MiscFeeType_REGULATORY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_EXCHFEE",MiscFeeType_EXCHFEE_get, MiscFeeType_EXCHFEE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_CONSUMPTION",MiscFeeType_CONSUMPTION_get, MiscFeeType_CONSUMPTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_STAMP",MiscFeeType_STAMP_get, MiscFeeType_STAMP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_TRANSFER_FEE",MiscFeeType_TRANSFER_FEE_get, MiscFeeType_TRANSFER_FEE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_AGENT",MiscFeeType_AGENT_get, MiscFeeType_AGENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_OTHER",MiscFeeType_OTHER_get, MiscFeeType_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_TRANSACTION",MiscFeeType_TRANSACTION_get, MiscFeeType_TRANSACTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_REG",MiscFeeType_REG_get, MiscFeeType_REG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_EXCHANGE_FEES",MiscFeeType_EXCHANGE_FEES_get, MiscFeeType_EXCHANGE_FEES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_LEVY",MiscFeeType_LEVY_get, MiscFeeType_LEVY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_CLEARING_HOUSE",SecurityIDSource_CLEARING_HOUSE_get, SecurityIDSource_CLEARING_HOUSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_OPTION_PRICE_REPORTING_AUTHORITY",SecurityIDSource_OPTION_PRICE_REPORTING_AUTHORITY_get, SecurityIDSource_OPTION_PRICE_REPORTING_AUTHORITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_EXCHANGE_SYMBOL",SecurityIDSource_EXCHANGE_SYMBOL_get, SecurityIDSource_EXCHANGE_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_SICOVAM",SecurityIDSource_SICOVAM_get, SecurityIDSource_SICOVAM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_ISDA_FPML_PRODUCT_SPECIFICATION",SecurityIDSource_ISDA_FPML_PRODUCT_SPECIFICATION_get, SecurityIDSource_ISDA_FPML_PRODUCT_SPECIFICATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_ISDA_FPML_PRODUCT_URL",SecurityIDSource_ISDA_FPML_PRODUCT_URL_get, SecurityIDSource_ISDA_FPML_PRODUCT_URL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_RIC",SecurityIDSource_RIC_get, SecurityIDSource_RIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_CLEARINGHOUSE",SecurityIDSource_CLEARINGHOUSE_get, SecurityIDSource_CLEARINGHOUSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_FPML",SecurityIDSource_FPML_get, SecurityIDSource_FPML_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_RIC_CODE",SecurityIDSource_RIC_CODE_get, SecurityIDSource_RIC_CODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_ISOCURR",SecurityIDSource_ISOCURR_get, SecurityIDSource_ISOCURR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_ISO_CURRENCY_CODE",SecurityIDSource_ISO_CURRENCY_CODE_get, SecurityIDSource_ISO_CURRENCY_CODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_COMMON",SecurityIDSource_COMMON_get, SecurityIDSource_COMMON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_VALOREN",SecurityIDSource_VALOREN_get, SecurityIDSource_VALOREN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_BELGIAN",SecurityIDSource_BELGIAN_get, SecurityIDSource_BELGIAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_CTA",SecurityIDSource_CTA_get, SecurityIDSource_CTA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_ISIN_NUMBER",SecurityIDSource_ISIN_NUMBER_get, SecurityIDSource_ISIN_NUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_ISIN",SecurityIDSource_ISIN_get, SecurityIDSource_ISIN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_ISOCOUNTRY",SecurityIDSource_ISOCOUNTRY_get, SecurityIDSource_ISOCOUNTRY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_SEDOL",SecurityIDSource_SEDOL_get, SecurityIDSource_SEDOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_ISO_COUNTRY_CODE",SecurityIDSource_ISO_COUNTRY_CODE_get, SecurityIDSource_ISO_COUNTRY_CODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_LETTER_OF_CREDIT",SecurityIDSource_LETTER_OF_CREDIT_get, SecurityIDSource_LETTER_OF_CREDIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_BLOOMBERG_SYMBOL",SecurityIDSource_BLOOMBERG_SYMBOL_get, SecurityIDSource_BLOOMBERG_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_BLMBRG",SecurityIDSource_BLMBRG_get, SecurityIDSource_BLMBRG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_OPTIONPRICEREPORTINGAUTHORITY",SecurityIDSource_OPTIONPRICEREPORTINGAUTHORITY_get, SecurityIDSource_OPTIONPRICEREPORTINGAUTHORITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_WERTPAPIER",SecurityIDSource_WERTPAPIER_get, SecurityIDSource_WERTPAPIER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_MARKETPLACE_ASSIGNED_IDENTIFIER",SecurityIDSource_MARKETPLACE_ASSIGNED_IDENTIFIER_get, SecurityIDSource_MARKETPLACE_ASSIGNED_IDENTIFIER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_EXCHSYMB",SecurityIDSource_EXCHSYMB_get, SecurityIDSource_EXCHSYMB_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_CONSOLIDATED_TAPE_ASSOCIATION",SecurityIDSource_CONSOLIDATED_TAPE_ASSOCIATION_get, SecurityIDSource_CONSOLIDATED_TAPE_ASSOCIATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_DUTCH",SecurityIDSource_DUTCH_get, SecurityIDSource_DUTCH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_QUIK",SecurityIDSource_QUIK_get, SecurityIDSource_QUIK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_CUSIP",SecurityIDSource_CUSIP_get, SecurityIDSource_CUSIP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NewsRefType_OTHER_LANGUAGE",NewsRefType_OTHER_LANGUAGE_get, NewsRefType_OTHER_LANGUAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NewsRefType_COMPLIMENTARY",NewsRefType_COMPLIMENTARY_get, NewsRefType_COMPLIMENTARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NewsRefType_REPLACEMENT",NewsRefType_REPLACEMENT_get, NewsRefType_REPLACEMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerOrderType_LIMIT",TriggerOrderType_LIMIT_get, TriggerOrderType_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerOrderType_MARKET",TriggerOrderType_MARKET_get, TriggerOrderType_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CrossType_CROSS_AON",CrossType_CROSS_AON_get, 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",CrossType_CROSS_TRADE_WHICH_IS_PARTIALLY_EXECUTED_WITH_THE_UNFILLED_PORTIONS_REMAINING_ACTIVE_ONE_SIDE_OF_THE_CROSS_IS_FULLY_EXECUTED_get, 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",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, 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_CROSSAON",CrossType_CROSSAON_get, CrossType_CROSSAON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CrossType_CROSS_TRADE_IS_EXECUTED_WITH_EXISTING_ORDERS_WITH_THE_SAME_PRICE",CrossType_CROSS_TRADE_IS_EXECUTED_WITH_EXISTING_ORDERS_WITH_THE_SAME_PRICE_get, CrossType_CROSS_TRADE_IS_EXECUTED_WITH_EXISTING_ORDERS_WITH_THE_SAME_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CrossType_CROSS_ONE_SIDE",CrossType_CROSS_ONE_SIDE_get, CrossType_CROSS_ONE_SIDE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CrossType_CROSS_SAME_PRICE",CrossType_CROSS_SAME_PRICE_get, CrossType_CROSS_SAME_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CrossType_CROSSSAMEPRICE",CrossType_CROSSSAMEPRICE_get, CrossType_CROSSSAMEPRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CrossType_CROSS_IOC",CrossType_CROSS_IOC_get, CrossType_CROSS_IOC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CrossType_CROSSIOC",CrossType_CROSSIOC_get, CrossType_CROSSIOC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CrossType_CROSSONESIDE",CrossType_CROSSONESIDE_get, CrossType_CROSSONESIDE_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",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, 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*)"OpenCloseSettleFlag_SESSION_OPEN",OpenCloseSettleFlag_SESSION_OPEN_get, OpenCloseSettleFlag_SESSION_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OpenCloseSettleFlag_DAILY_OPEN",OpenCloseSettleFlag_DAILY_OPEN_get, OpenCloseSettleFlag_DAILY_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OpenCloseSettleFlag_EXPECTED_PRICE",OpenCloseSettleFlag_EXPECTED_PRICE_get, OpenCloseSettleFlag_EXPECTED_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OpenCloseSettleFlag_PRICE_FROM_PREVIOUS_BUSINESS_DAY",OpenCloseSettleFlag_PRICE_FROM_PREVIOUS_BUSINESS_DAY_get, OpenCloseSettleFlag_PRICE_FROM_PREVIOUS_BUSINESS_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OpenCloseSettleFlag_DELIVERY_SETTLEMENT_PRICE",OpenCloseSettleFlag_DELIVERY_SETTLEMENT_PRICE_get, OpenCloseSettleFlag_DELIVERY_SETTLEMENT_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDBookType_PRICE_DEPTH",MDBookType_PRICE_DEPTH_get, MDBookType_PRICE_DEPTH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDBookType_ORDER_DEPTH",MDBookType_ORDER_DEPTH_get, MDBookType_ORDER_DEPTH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDBookType_TOP_OF_BOOK",MDBookType_TOP_OF_BOOK_get, MDBookType_TOP_OF_BOOK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_VWAPAFT",BasisPxType_VWAPAFT_get, BasisPxType_VWAPAFT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_VWAP_THROUGH_A_DAY_EXCEPT_YORI",BasisPxType_VWAP_THROUGH_A_DAY_EXCEPT_YORI_get, BasisPxType_VWAP_THROUGH_A_DAY_EXCEPT_YORI_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_VWAP_THROUGH_A_MORNING_SESSION",BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_get, BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_CLOSING_PRICE",BasisPxType_CLOSING_PRICE_get, BasisPxType_CLOSING_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_VWAP_THROUGH_A_DAY",BasisPxType_VWAP_THROUGH_A_DAY_get, BasisPxType_VWAP_THROUGH_A_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_CLOSING_PRICE_AT_MORNINGN_SESSION",BasisPxType_CLOSING_PRICE_AT_MORNINGN_SESSION_get, BasisPxType_CLOSING_PRICE_AT_MORNINGN_SESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_VWAPDAY",BasisPxType_VWAPDAY_get, BasisPxType_VWAPDAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_VWAPMORNXYORI",BasisPxType_VWAPMORNXYORI_get, BasisPxType_VWAPMORNXYORI_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_VWAPMORN",BasisPxType_VWAPMORN_get, BasisPxType_VWAPMORN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_VWAPDAYXYORI",BasisPxType_VWAPDAYXYORI_get, BasisPxType_VWAPDAYXYORI_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_OTHERS",BasisPxType_OTHERS_get, BasisPxType_OTHERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_OPEN",BasisPxType_OPEN_get, BasisPxType_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_CURRPX",BasisPxType_CURRPX_get, BasisPxType_CURRPX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_VWAPAFTXYORI",BasisPxType_VWAPAFTXYORI_get, BasisPxType_VWAPAFTXYORI_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_CLOSING_PRICE_AT_MORNING_SESSION",BasisPxType_CLOSING_PRICE_AT_MORNING_SESSION_get, BasisPxType_CLOSING_PRICE_AT_MORNING_SESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_CLSPXMORN",BasisPxType_CLSPXMORN_get, BasisPxType_CLSPXMORN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_CURRENT_PRICE",BasisPxType_CURRENT_PRICE_get, BasisPxType_CURRENT_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_SQ",BasisPxType_SQ_get, BasisPxType_SQ_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_CLSPX",BasisPxType_CLSPX_get, BasisPxType_CLSPX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_STRIKE",BasisPxType_STRIKE_get, BasisPxType_STRIKE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_EXCEPT_YORI",BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_EXCEPT_YORI_get, BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_EXCEPT_YORI_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_EXCEPT_YORI",BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_EXCEPT_YORI_get, BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_EXCEPT_YORI_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION",BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_get, BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventType_ROLLING_BARRIER",ComplexEventType_ROLLING_BARRIER_get, ComplexEventType_ROLLING_BARRIER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventType_UNDERLYING",ComplexEventType_UNDERLYING_get, ComplexEventType_UNDERLYING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventType_KNOCK_OUT_UP",ComplexEventType_KNOCK_OUT_UP_get, ComplexEventType_KNOCK_OUT_UP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventType_KNOCK_IN_UP",ComplexEventType_KNOCK_IN_UP_get, ComplexEventType_KNOCK_IN_UP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventType_KOCK_IN_DOWN",ComplexEventType_KOCK_IN_DOWN_get, ComplexEventType_KOCK_IN_DOWN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventType_TRIGGER",ComplexEventType_TRIGGER_get, ComplexEventType_TRIGGER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventType_RESET_BARRIER",ComplexEventType_RESET_BARRIER_get, ComplexEventType_RESET_BARRIER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventType_CAPPED",ComplexEventType_CAPPED_get, ComplexEventType_CAPPED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventType_KNOCK_OUT_DOWN",ComplexEventType_KNOCK_OUT_DOWN_get, ComplexEventType_KNOCK_OUT_DOWN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionResponse_REJECTED",MassActionResponse_REJECTED_get, MassActionResponse_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionResponse_ACCEPTED",MassActionResponse_ACCEPTED_get, MassActionResponse_ACCEPTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID",SecurityRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID_get, SecurityRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestType_REQUEST_LIST_SECURITY_TYPES",SecurityRequestType_REQUEST_LIST_SECURITY_TYPES_get, SecurityRequestType_REQUEST_LIST_SECURITY_TYPES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestType_REQSECIDPROV",SecurityRequestType_REQSECIDPROV_get, SecurityRequestType_REQSECIDPROV_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestType_REQUEST_LIST_SECURITIES",SecurityRequestType_REQUEST_LIST_SECURITIES_get, SecurityRequestType_REQUEST_LIST_SECURITIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestType_REQSECID",SecurityRequestType_REQSECID_get, SecurityRequestType_REQSECID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestType_SYMBOL",SecurityRequestType_SYMBOL_get, SecurityRequestType_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestType_SECURITYTYPE_AND_OR_CFICODE",SecurityRequestType_SECURITYTYPE_AND_OR_CFICODE_get, SecurityRequestType_SECURITYTYPE_AND_OR_CFICODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestType_REQUEST_SECURITY_IDENTITY_FOR_THE_SPECIFICATIONS_PROVIDED",SecurityRequestType_REQUEST_SECURITY_IDENTITY_FOR_THE_SPECIFICATIONS_PROVIDED_get, SecurityRequestType_REQUEST_SECURITY_IDENTITY_FOR_THE_SPECIFICATIONS_PROVIDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestType_REQSECLIST",SecurityRequestType_REQSECLIST_get, SecurityRequestType_REQSECLIST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestType_TRADINGSESSIONID",SecurityRequestType_TRADINGSESSIONID_get, SecurityRequestType_TRADINGSESSIONID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestType_PRODUCT",SecurityRequestType_PRODUCT_get, SecurityRequestType_PRODUCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestType_ALL_SECURITIES",SecurityRequestType_ALL_SECURITIES_get, SecurityRequestType_ALL_SECURITIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestType_REQSECLISTTYPES",SecurityRequestType_REQSECLISTTYPES_get, SecurityRequestType_REQSECLISTTYPES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestType_REQUEST_SECURITY_IDENTITY_AND_SPECIFICATIONS",SecurityRequestType_REQUEST_SECURITY_IDENTITY_AND_SPECIFICATIONS_get, SecurityRequestType_REQUEST_SECURITY_IDENTITY_AND_SPECIFICATIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListRejectReason_EXCHANGE_CLOSED",ListRejectReason_EXCHANGE_CLOSED_get, ListRejectReason_EXCHANGE_CLOSED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListRejectReason_UNKNOWN_ORDER",ListRejectReason_UNKNOWN_ORDER_get, ListRejectReason_UNKNOWN_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListRejectReason_UNSUPPORTED_ORDER_CHARACTERISTIC",ListRejectReason_UNSUPPORTED_ORDER_CHARACTERISTIC_get, ListRejectReason_UNSUPPORTED_ORDER_CHARACTERISTIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListRejectReason_DUPLICATE_ORDER",ListRejectReason_DUPLICATE_ORDER_get, ListRejectReason_DUPLICATE_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListRejectReason_TOO_LATE_TO_ENTER",ListRejectReason_TOO_LATE_TO_ENTER_get, ListRejectReason_TOO_LATE_TO_ENTER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListRejectReason_OTHER",ListRejectReason_OTHER_get, ListRejectReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListRejectReason_BROKER",ListRejectReason_BROKER_get, ListRejectReason_BROKER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskType_PROPRIETARY",DeskType_PROPRIETARY_get, DeskType_PROPRIETARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskType_ARBITRAGE",DeskType_ARBITRAGE_get, DeskType_ARBITRAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskType_TRADING",DeskType_TRADING_get, DeskType_TRADING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskType_DERIVATIVES",DeskType_DERIVATIVES_get, DeskType_DERIVATIVES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskType_SALES",DeskType_SALES_get, DeskType_SALES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskType_INSTITUTIONAL",DeskType_INSTITUTIONAL_get, DeskType_INSTITUTIONAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskType_INTERNATIONAL",DeskType_INTERNATIONAL_get, DeskType_INTERNATIONAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskType_AGENCY",DeskType_AGENCY_get, DeskType_AGENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskType_PREFERRED_TRADING",DeskType_PREFERRED_TRADING_get, DeskType_PREFERRED_TRADING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskType_OTHER",DeskType_OTHER_get, DeskType_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskType_PROGRAM_TRADING",DeskType_PROGRAM_TRADING_get, DeskType_PROGRAM_TRADING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlType_T4",SettlType_T4_get, SettlType_T4_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlType_T5",SettlType_T5_get, SettlType_T5_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlType_WHEN_AND_IF_ISSUED",SettlType_WHEN_AND_IF_ISSUED_get, SettlType_WHEN_AND_IF_ISSUED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlType_NEXTDAY",SettlType_NEXTDAY_get, SettlType_NEXTDAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlType_FUTURE",SettlType_FUTURE_get, SettlType_FUTURE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlType_T_PLUS_2",SettlType_T_PLUS_2_get, SettlType_T_PLUS_2_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlType_SELLERS_OPTION",SettlType_SELLERS_OPTION_get, SettlType_SELLERS_OPTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlType_BROKEN_DATE",SettlType_BROKEN_DATE_get, SettlType_BROKEN_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlType_T_PLUS_3",SettlType_T_PLUS_3_get, SettlType_T_PLUS_3_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlType_T_PLUS_4",SettlType_T_PLUS_4_get, SettlType_T_PLUS_4_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlType_REGULAR",SettlType_REGULAR_get, SettlType_REGULAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlType_NEXT_DAY",SettlType_NEXT_DAY_get, SettlType_NEXT_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlType_T_PLUS_5",SettlType_T_PLUS_5_get, SettlType_T_PLUS_5_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlType_FX_SPOT_NEXT_SETTLEMENT",SettlType_FX_SPOT_NEXT_SETTLEMENT_get, SettlType_FX_SPOT_NEXT_SETTLEMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlType_T1",SettlType_T1_get, SettlType_T1_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlType_WHENISSUED",SettlType_WHENISSUED_get, SettlType_WHENISSUED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlType_T2",SettlType_T2_get, SettlType_T2_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlType_T3",SettlType_T3_get, SettlType_T3_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlType_CASH",SettlType_CASH_get, SettlType_CASH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OpenClose_CLOSE",OpenClose_CLOSE_get, OpenClose_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OpenClose_OPEN",OpenClose_OPEN_get, OpenClose_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContractMultiplierUnit_SHARES",ContractMultiplierUnit_SHARES_get, ContractMultiplierUnit_SHARES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContractMultiplierUnit_HOURS",ContractMultiplierUnit_HOURS_get, ContractMultiplierUnit_HOURS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContractMultiplierUnit_DAYS",ContractMultiplierUnit_DAYS_get, ContractMultiplierUnit_DAYS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_VOLUME_WEIGHTED_AVERAGE_TRADE",TrdType_VOLUME_WEIGHTED_AVERAGE_TRADE_get, TrdType_VOLUME_WEIGHTED_AVERAGE_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_LATE_TRADE",TrdType_LATE_TRADE_get, TrdType_LATE_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_FUTURES_LARGE_ORDER_EXECUTION",TrdType_FUTURES_LARGE_ORDER_EXECUTION_get, TrdType_FUTURES_LARGE_ORDER_EXECUTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_EXCHANGE_OF_FUTURES_FOR_FUTURES",TrdType_EXCHANGE_OF_FUTURES_FOR_FUTURES_get, TrdType_EXCHANGE_OF_FUTURES_FOR_FUTURES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_SPECIAL_EX_CAPITAL_REPAYMENTS",TrdType_SPECIAL_EX_CAPITAL_REPAYMENTS_get, TrdType_SPECIAL_EX_CAPITAL_REPAYMENTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_BLOCK_TRADE_38",TrdType_BLOCK_TRADE_38_get, TrdType_BLOCK_TRADE_38_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_DELTA_NEUTRAL_TRANSACTION",TrdType_DELTA_NEUTRAL_TRANSACTION_get, TrdType_DELTA_NEUTRAL_TRANSACTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_CASH_SETTLEMENT",TrdType_CASH_SETTLEMENT_get, TrdType_CASH_SETTLEMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_SPECIAL_CUM_CAPITAL_REPAYMENTS",TrdType_SPECIAL_CUM_CAPITAL_REPAYMENTS_get, TrdType_SPECIAL_CUM_CAPITAL_REPAYMENTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_SPECIAL_CUM_BONUS",TrdType_SPECIAL_CUM_BONUS_get, TrdType_SPECIAL_CUM_BONUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_BLOCK_TRADES",TrdType_BLOCK_TRADES_get, TrdType_BLOCK_TRADES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_ALL_OR_NONE",TrdType_ALL_OR_NONE_get, TrdType_ALL_OR_NONE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_OPTION_EXERCISE",TrdType_OPTION_EXERCISE_get, TrdType_OPTION_EXERCISE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_FINANCING_TRANSACTION",TrdType_FINANCING_TRANSACTION_get, TrdType_FINANCING_TRANSACTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_TRANSFER",TrdType_TRANSFER_get, TrdType_TRANSFER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_REGULAR_TRADE",TrdType_REGULAR_TRADE_get, TrdType_REGULAR_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_TRADING_AT_SETTLEMENT",TrdType_TRADING_AT_SETTLEMENT_get, TrdType_TRADING_AT_SETTLEMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_SPECIAL_EX_DIVIDEND",TrdType_SPECIAL_EX_DIVIDEND_get, TrdType_SPECIAL_EX_DIVIDEND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_SPECIAL_EX_COUPON",TrdType_SPECIAL_EX_COUPON_get, TrdType_SPECIAL_EX_COUPON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_SPECIAL_PRICE",TrdType_SPECIAL_PRICE_get, TrdType_SPECIAL_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_SPECIAL_CUM_RIGHTS",TrdType_SPECIAL_CUM_RIGHTS_get, TrdType_SPECIAL_CUM_RIGHTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_SPECIAL_EX_BONUS",TrdType_SPECIAL_EX_BONUS_get, TrdType_SPECIAL_EX_BONUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_BLOCKTRADE",TrdType_BLOCKTRADE_get, TrdType_BLOCKTRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_EXCHANGE_GRANTED_TRADE",TrdType_EXCHANGE_GRANTED_TRADE_get, TrdType_EXCHANGE_GRANTED_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_EXCHANGE_BASIS_FACILITY",TrdType_EXCHANGE_BASIS_FACILITY_get, TrdType_EXCHANGE_BASIS_FACILITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_BLOCK_TRADE_1",TrdType_BLOCK_TRADE_1_get, TrdType_BLOCK_TRADE_1_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_LATE_BUNCHED_TRADE",TrdType_LATE_BUNCHED_TRADE_get, TrdType_LATE_BUNCHED_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_ERROR_TRADE",TrdType_ERROR_TRADE_get, TrdType_ERROR_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_NAME_CHANGE",TrdType_NAME_CHANGE_get, TrdType_NAME_CHANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_LATEBUNCHEDTRADE",TrdType_LATEBUNCHEDTRADE_get, TrdType_LATEBUNCHEDTRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_EFP",TrdType_EFP_get, TrdType_EFP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_NON_STANDARD_SETTLEMENT",TrdType_NON_STANDARD_SETTLEMENT_get, TrdType_NON_STANDARD_SETTLEMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_PRIOR_REFERENCE_PRICE_TRADE",TrdType_PRIOR_REFERENCE_PRICE_TRADE_get, TrdType_PRIOR_REFERENCE_PRICE_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_EXCHANGE_FOR_RISK",TrdType_EXCHANGE_FOR_RISK_get, TrdType_EXCHANGE_FOR_RISK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_EXCHANGE_FOR_SWAP",TrdType_EXCHANGE_FOR_SWAP_get, TrdType_EXCHANGE_FOR_SWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_EXCHANGE_OF_FUTURES_FOR",TrdType_EXCHANGE_OF_FUTURES_FOR_get, TrdType_EXCHANGE_OF_FUTURES_FOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_OPTION_INTERIM_TRADE",TrdType_OPTION_INTERIM_TRADE_get, TrdType_OPTION_INTERIM_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_PRIVATELY_NEGOTIATED_TRADES",TrdType_PRIVATELY_NEGOTIATED_TRADES_get, TrdType_PRIVATELY_NEGOTIATED_TRADES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_SUBSTITUTION_OF_FUTURES_FOR_FORWARDS",TrdType_SUBSTITUTION_OF_FUTURES_FOR_FORWARDS_get, TrdType_SUBSTITUTION_OF_FUTURES_FOR_FORWARDS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_SPECIAL_CUM_DIVIDEND",TrdType_SPECIAL_CUM_DIVIDEND_get, TrdType_SPECIAL_CUM_DIVIDEND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_GUARANTEED_DELIVERY",TrdType_GUARANTEED_DELIVERY_get, TrdType_GUARANTEED_DELIVERY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_PROROGATION_SELL",TrdType_PROROGATION_SELL_get, TrdType_PROROGATION_SELL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_WEIGHTEDAVERAGEPRICETRADE",TrdType_WEIGHTEDAVERAGEPRICETRADE_get, TrdType_WEIGHTEDAVERAGEPRICETRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_PORTFOLIO_TRADE",TrdType_PORTFOLIO_TRADE_get, TrdType_PORTFOLIO_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_WEIGHTED_AVERAGE_PRICE_TRADE",TrdType_WEIGHTED_AVERAGE_PRICE_TRADE_get, TrdType_WEIGHTED_AVERAGE_PRICE_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_WORKED_PRINCIPAL_TRADE",TrdType_WORKED_PRINCIPAL_TRADE_get, TrdType_WORKED_PRINCIPAL_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_PORTFOLIO_TRANSFER",TrdType_PORTFOLIO_TRANSFER_get, TrdType_PORTFOLIO_TRANSFER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_T_TRADE",TrdType_T_TRADE_get, TrdType_T_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_EXCHANGE_OF_OPTIONS_FOR_OPTIONS",TrdType_EXCHANGE_OF_OPTIONS_FOR_OPTIONS_get, TrdType_EXCHANGE_OF_OPTIONS_FOR_OPTIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_SPECIAL_CUM_COUPON",TrdType_SPECIAL_CUM_COUPON_get, TrdType_SPECIAL_CUM_COUPON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_BUNCHEDTRADE",TrdType_BUNCHEDTRADE_get, TrdType_BUNCHEDTRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_TTRADE",TrdType_TTRADE_get, TrdType_TTRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_OTC",TrdType_OTC_get, TrdType_OTC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_AFTER_HOURS_TRADE",TrdType_AFTER_HOURS_TRADE_get, TrdType_AFTER_HOURS_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_PRIORREFERENCEPRICETRADE",TrdType_PRIORREFERENCEPRICETRADE_get, TrdType_PRIORREFERENCEPRICETRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_AFTERHOURSTRADE",TrdType_AFTERHOURSTRADE_get, TrdType_AFTERHOURSTRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_DERIVATIVE_RELATED_TRANSACTION",TrdType_DERIVATIVE_RELATED_TRANSACTION_get, TrdType_DERIVATIVE_RELATED_TRANSACTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_REPURCHASE_AGREEMENT",TrdType_REPURCHASE_AGREEMENT_get, TrdType_REPURCHASE_AGREEMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_SPECIAL_EX_RIGHTS",TrdType_SPECIAL_EX_RIGHTS_get, TrdType_SPECIAL_EX_RIGHTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_PROROGATION_BUY",TrdType_PROROGATION_BUY_get, TrdType_PROROGATION_BUY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_BUNCHED_TRADE",TrdType_BUNCHED_TRADE_get, TrdType_BUNCHED_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_OPTION_CABINET_TRADE",TrdType_OPTION_CABINET_TRADE_get, TrdType_OPTION_CABINET_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_LATETRADE",TrdType_LATETRADE_get, TrdType_LATETRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_REGULARTRADE",TrdType_REGULARTRADE_get, TrdType_REGULARTRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RestructuringType_MODIFIED_MOD_RESTRUCTURING",RestructuringType_MODIFIED_MOD_RESTRUCTURING_get, RestructuringType_MODIFIED_MOD_RESTRUCTURING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RestructuringType_FULL_RESTRUCTURING",RestructuringType_FULL_RESTRUCTURING_get, RestructuringType_FULL_RESTRUCTURING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RestructuringType_NO_RESTRUCTURING_SPECIFIED",RestructuringType_NO_RESTRUCTURING_SPECIFIED_get, RestructuringType_NO_RESTRUCTURING_SPECIFIED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RestructuringType_MODIFIED_RESTRUCTURING",RestructuringType_MODIFIED_RESTRUCTURING_get, RestructuringType_MODIFIED_RESTRUCTURING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ProgRptReqs_SELLSIDE",ProgRptReqs_SELLSIDE_get, ProgRptReqs_SELLSIDE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ProgRptReqs_REALTIME",ProgRptReqs_REALTIME_get, ProgRptReqs_REALTIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ProgRptReqs_REAL_TIME_EXECUTION_REPORTS",ProgRptReqs_REAL_TIME_EXECUTION_REPORTS_get, ProgRptReqs_REAL_TIME_EXECUTION_REPORTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ProgRptReqs_BUYSIDE_EXPLICITLY_REQUESTS_STATUS_USING_STATUSREQUEST",ProgRptReqs_BUYSIDE_EXPLICITLY_REQUESTS_STATUS_USING_STATUSREQUEST_get, 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",ProgRptReqs_SELL_SIDE_PERIODICALLY_SENDS_STATUS_USING_LIST_STATUS_PERIOD_OPTIONALLY_SPECIFIED_IN_PROGRESSPERIOD_get, 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",ProgRptReqs_BUY_SIDE_EXPLICITLY_REQUESTS_STATUS_USING_STATUE_REQUEST_get, ProgRptReqs_BUY_SIDE_EXPLICITLY_REQUESTS_STATUS_USING_STATUE_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ProgRptReqs_BUYSIDE",ProgRptReqs_BUYSIDE_get, ProgRptReqs_BUYSIDE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ProgRptReqs_SELLSIDE_PERIODICALLY_SENDS_STATUS_USING_LISTSTATUS_PERIOD_OPTIONALLY_SPECIFIED_IN_PROGRESSPERIOD",ProgRptReqs_SELLSIDE_PERIODICALLY_SENDS_STATUS_USING_LISTSTATUS_PERIOD_OPTIONALLY_SPECIFIED_IN_PROGRESSPERIOD_get, ProgRptReqs_SELLSIDE_PERIODICALLY_SENDS_STATUS_USING_LISTSTATUS_PERIOD_OPTIONALLY_SPECIFIED_IN_PROGRESSPERIOD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradingSessionID_EVENING",TradingSessionID_EVENING_get, TradingSessionID_EVENING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradingSessionID_AFTER_HOURS",TradingSessionID_AFTER_HOURS_get, TradingSessionID_AFTER_HOURS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradingSessionID_HALFDAY",TradingSessionID_HALFDAY_get, TradingSessionID_HALFDAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradingSessionID_DAY",TradingSessionID_DAY_get, TradingSessionID_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradingSessionID_MORNING",TradingSessionID_MORNING_get, TradingSessionID_MORNING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradingSessionID_AFTERNOON",TradingSessionID_AFTERNOON_get, TradingSessionID_AFTERNOON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListOrderStatus_RECVFOREXEC",ListOrderStatus_RECVFOREXEC_get, ListOrderStatus_RECVFOREXEC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListOrderStatus_CXL",ListOrderStatus_CXL_get, ListOrderStatus_CXL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListOrderStatus_REJ",ListOrderStatus_REJ_get, ListOrderStatus_REJ_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListOrderStatus_CANCELING",ListOrderStatus_CANCELING_get, ListOrderStatus_CANCELING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListOrderStatus_REJECT",ListOrderStatus_REJECT_get, ListOrderStatus_REJECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListOrderStatus_ALL_DONE",ListOrderStatus_ALL_DONE_get, ListOrderStatus_ALL_DONE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListOrderStatus_INBIDPROC",ListOrderStatus_INBIDPROC_get, ListOrderStatus_INBIDPROC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListOrderStatus_ALLDONE",ListOrderStatus_ALLDONE_get, ListOrderStatus_ALLDONE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListOrderStatus_IN_BIDDING_PROCESS",ListOrderStatus_IN_BIDDING_PROCESS_get, ListOrderStatus_IN_BIDDING_PROCESS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListOrderStatus_RECEIVED_FOR_EXECUTION",ListOrderStatus_RECEIVED_FOR_EXECUTION_get, ListOrderStatus_RECEIVED_FOR_EXECUTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListOrderStatus_ALERT",ListOrderStatus_ALERT_get, ListOrderStatus_ALERT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListOrderStatus_RECEIVEDFOREXECUTION",ListOrderStatus_RECEIVEDFOREXECUTION_get, ListOrderStatus_RECEIVEDFOREXECUTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListOrderStatus_INBIDDINGPROCESS",ListOrderStatus_INBIDDINGPROCESS_get, ListOrderStatus_INBIDDINGPROCESS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListOrderStatus_EXEC",ListOrderStatus_EXEC_get, ListOrderStatus_EXEC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListOrderStatus_CANCELLING",ListOrderStatus_CANCELLING_get, ListOrderStatus_CANCELLING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListOrderStatus_EXECUTING",ListOrderStatus_EXECUTING_get, ListOrderStatus_EXECUTING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistStatus_REJECT",RegistStatus_REJECT_get, RegistStatus_REJECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistStatus_REMINDER_IE_REGISTRATION_INSTRUCTIONS_ARE_STILL_OUTSTANDING",RegistStatus_REMINDER_IE_REGISTRATION_INSTRUCTIONS_ARE_STILL_OUTSTANDING_get, RegistStatus_REMINDER_IE_REGISTRATION_INSTRUCTIONS_ARE_STILL_OUTSTANDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistStatus_REJECTED",RegistStatus_REJECTED_get, RegistStatus_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistStatus_ACCEPTED",RegistStatus_ACCEPTED_get, RegistStatus_ACCEPTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistStatus_REMINDER",RegistStatus_REMINDER_get, RegistStatus_REMINDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistStatus_HELD",RegistStatus_HELD_get, RegistStatus_HELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistStatus_ACCEPT",RegistStatus_ACCEPT_get, RegistStatus_ACCEPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnderlyingPriceDeterminationMethod_OPTIMAL_VALUE",UnderlyingPriceDeterminationMethod_OPTIMAL_VALUE_get, UnderlyingPriceDeterminationMethod_OPTIMAL_VALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnderlyingPriceDeterminationMethod_SPECIAL_REFERENCE",UnderlyingPriceDeterminationMethod_SPECIAL_REFERENCE_get, UnderlyingPriceDeterminationMethod_SPECIAL_REFERENCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnderlyingPriceDeterminationMethod_AVERAGE_VALUE",UnderlyingPriceDeterminationMethod_AVERAGE_VALUE_get, UnderlyingPriceDeterminationMethod_AVERAGE_VALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnderlyingPriceDeterminationMethod_REGULAR",UnderlyingPriceDeterminationMethod_REGULAR_get, UnderlyingPriceDeterminationMethod_REGULAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY",MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_get, MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_GROUP",MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_GROUP_get, MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_GROUP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRequestType_CXLORDERSSECURITYTYPE",MassCancelRequestType_CXLORDERSSECURITYTYPE_get, MassCancelRequestType_CXLORDERSSECURITYTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRequestType_CXLORDERSUNDERLYINGSECURITY",MassCancelRequestType_CXLORDERSUNDERLYINGSECURITY_get, MassCancelRequestType_CXLORDERSUNDERLYINGSECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRequestType_CXLORDERSTRDSESSION",MassCancelRequestType_CXLORDERSTRDSESSION_get, MassCancelRequestType_CXLORDERSTRDSESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRequestType_CXLALLORDERS",MassCancelRequestType_CXLALLORDERS_get, MassCancelRequestType_CXLALLORDERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET",MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_get, MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT",MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT_get, MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITYTYPE",MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITYTYPE_get, MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITYTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRequestType_CANCEL_ORDERS_FOR_A_TRADING_SESSION",MassCancelRequestType_CANCEL_ORDERS_FOR_A_TRADING_SESSION_get, MassCancelRequestType_CANCEL_ORDERS_FOR_A_TRADING_SESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRequestType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY",MassCancelRequestType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_get, MassCancelRequestType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRequestType_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY",MassCancelRequestType_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY_get, MassCancelRequestType_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRequestType_CXLORDERSSECURITY",MassCancelRequestType_CXLORDERSSECURITY_get, MassCancelRequestType_CXLORDERSSECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRequestType_CXLORDERSPRODUCT",MassCancelRequestType_CXLORDERSPRODUCT_get, MassCancelRequestType_CXLORDERSPRODUCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRequestType_CANCEL_ALL_ORDERS",MassCancelRequestType_CANCEL_ALL_ORDERS_get, MassCancelRequestType_CANCEL_ALL_ORDERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRequestType_CANCEL_FOR_SECURITY_ISSUER",MassCancelRequestType_CANCEL_FOR_SECURITY_ISSUER_get, MassCancelRequestType_CANCEL_FOR_SECURITY_ISSUER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRequestType_CXLORDERSCFICODE",MassCancelRequestType_CXLORDERSCFICODE_get, MassCancelRequestType_CXLORDERSCFICODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRequestType_CANCEL_ORDERS_FOR_A_PRODUCT",MassCancelRequestType_CANCEL_ORDERS_FOR_A_PRODUCT_get, MassCancelRequestType_CANCEL_ORDERS_FOR_A_PRODUCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRequestType_CANCEL_ORDERS_FOR_A_CFICODE",MassCancelRequestType_CANCEL_ORDERS_FOR_A_CFICODE_get, MassCancelRequestType_CANCEL_ORDERS_FOR_A_CFICODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DerivativeSecurityListRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID",DerivativeSecurityListRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID_get, DerivativeSecurityListRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DerivativeSecurityListRequestType_UNDELYINGSYMBOL",DerivativeSecurityListRequestType_UNDELYINGSYMBOL_get, DerivativeSecurityListRequestType_UNDELYINGSYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DerivativeSecurityListRequestType_UNDERLYING_PRODUCT",DerivativeSecurityListRequestType_UNDERLYING_PRODUCT_get, DerivativeSecurityListRequestType_UNDERLYING_PRODUCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DerivativeSecurityListRequestType_UNDERLYING_SECURITYTYPE_AND_OR_CFICODE",DerivativeSecurityListRequestType_UNDERLYING_SECURITYTYPE_AND_OR_CFICODE_get, DerivativeSecurityListRequestType_UNDERLYING_SECURITYTYPE_AND_OR_CFICODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DerivativeSecurityListRequestType_SECURITYTYPE_AND_OR_CFICODE",DerivativeSecurityListRequestType_SECURITYTYPE_AND_OR_CFICODE_get, DerivativeSecurityListRequestType_SECURITYTYPE_AND_OR_CFICODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DerivativeSecurityListRequestType_SYMBOL",DerivativeSecurityListRequestType_SYMBOL_get, DerivativeSecurityListRequestType_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DerivativeSecurityListRequestType_TRADINGSESSIONID",DerivativeSecurityListRequestType_TRADINGSESSIONID_get, DerivativeSecurityListRequestType_TRADINGSESSIONID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DerivativeSecurityListRequestType_ALL_SECURITIES",DerivativeSecurityListRequestType_ALL_SECURITIES_get, DerivativeSecurityListRequestType_ALL_SECURITIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DerivativeSecurityListRequestType_PRODUCT",DerivativeSecurityListRequestType_PRODUCT_get, DerivativeSecurityListRequestType_PRODUCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejResponseTo_ORDCXLREPREQ",CxlRejResponseTo_ORDCXLREPREQ_get, CxlRejResponseTo_ORDCXLREPREQ_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejResponseTo_ORDER_CANCEL_REQUEST",CxlRejResponseTo_ORDER_CANCEL_REQUEST_get, CxlRejResponseTo_ORDER_CANCEL_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejResponseTo_ORDER_CANCEL_REPLACE_REQUEST",CxlRejResponseTo_ORDER_CANCEL_REPLACE_REQUEST_get, CxlRejResponseTo_ORDER_CANCEL_REPLACE_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejResponseTo_ORDCXLREQ",CxlRejResponseTo_ORDCXLREQ_get, CxlRejResponseTo_ORDCXLREQ_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCancelType_CANCEL_BY_QUOTETYPE",QuoteCancelType_CANCEL_BY_QUOTETYPE_get, QuoteCancelType_CANCEL_BY_QUOTETYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCancelType_CANCEL_FOR_ONE_OR_MORE_SECURITIES",QuoteCancelType_CANCEL_FOR_ONE_OR_MORE_SECURITIES_get, QuoteCancelType_CANCEL_FOR_ONE_OR_MORE_SECURITIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCancelType_CANCEL_QUOTE_SPECIFIED_IN_QUOTEID",QuoteCancelType_CANCEL_QUOTE_SPECIFIED_IN_QUOTEID_get, QuoteCancelType_CANCEL_QUOTE_SPECIFIED_IN_QUOTEID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCancelType_CANCEL_FOR_UNDERLYING_SYMBOL",QuoteCancelType_CANCEL_FOR_UNDERLYING_SYMBOL_get, QuoteCancelType_CANCEL_FOR_UNDERLYING_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCancelType_CXLUNDER",QuoteCancelType_CXLUNDER_get, QuoteCancelType_CXLUNDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCancelType_CANCEL_ALL_QUOTES",QuoteCancelType_CANCEL_ALL_QUOTES_get, QuoteCancelType_CANCEL_ALL_QUOTES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCancelType_CXLSYM",QuoteCancelType_CXLSYM_get, QuoteCancelType_CXLSYM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCancelType_CANCEL_FOR_UNDERLYING_SECURITY",QuoteCancelType_CANCEL_FOR_UNDERLYING_SECURITY_get, QuoteCancelType_CANCEL_FOR_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCancelType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY",QuoteCancelType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_get, QuoteCancelType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCancelType_CANCEL_FOR_SECURITY_ISSUER",QuoteCancelType_CANCEL_FOR_SECURITY_ISSUER_get, QuoteCancelType_CANCEL_FOR_SECURITY_ISSUER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCancelType_CXLSECTYPE",QuoteCancelType_CXLSECTYPE_get, QuoteCancelType_CXLSECTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCancelType_CANCEL_FOR_ALL_QUOTES",QuoteCancelType_CANCEL_FOR_ALL_QUOTES_get, QuoteCancelType_CANCEL_FOR_ALL_QUOTES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCancelType_CXLALL",QuoteCancelType_CXLALL_get, QuoteCancelType_CXLALL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCancelType_CANCEL_FOR_SECURITY_TYPE",QuoteCancelType_CANCEL_FOR_SECURITY_TYPE_get, QuoteCancelType_CANCEL_FOR_SECURITY_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCancelType_CANCEL_FOR_SYMBOL",QuoteCancelType_CANCEL_FOR_SYMBOL_get, QuoteCancelType_CANCEL_FOR_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_POOLS_PER_LOT",StipulationType_POOLS_PER_LOT_get, StipulationType_POOLS_PER_LOT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_MAXIMUM_LOAN_BALANCE",StipulationType_MAXIMUM_LOAN_BALANCE_get, StipulationType_MAXIMUM_LOAN_BALANCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_CONSTANTPREPAYMENTYIELD",StipulationType_CONSTANTPREPAYMENTYIELD_get, StipulationType_CONSTANTPREPAYMENTYIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_CUSTOM_START_END_DATE",StipulationType_CUSTOM_START_END_DATE_get, StipulationType_CUSTOM_START_END_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_CALL_PROTECTION",StipulationType_CALL_PROTECTION_get, StipulationType_CALL_PROTECTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_MATURITYYEARANDMONTH",StipulationType_MATURITYYEARANDMONTH_get, StipulationType_MATURITYYEARANDMONTH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_FINALCPROFHOMEEQUITYPREPAYMENTCURVE",StipulationType_FINALCPROFHOMEEQUITYPREPAYMENTCURVE_get, StipulationType_FINALCPROFHOMEEQUITYPREPAYMENTCURVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_MATURITYRANGE",StipulationType_MATURITYRANGE_get, StipulationType_MATURITYRANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_COUPON_RANGE",StipulationType_COUPON_RANGE_get, StipulationType_COUPON_RANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_PERCENTOFBMAPREPAYMENTCURVE",StipulationType_PERCENTOFBMAPREPAYMENTCURVE_get, StipulationType_PERCENTOFBMAPREPAYMENTCURVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_SUBSTITUTIONSLEFTREPO",StipulationType_SUBSTITUTIONSLEFTREPO_get, StipulationType_SUBSTITUTIONSLEFTREPO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_LOOKBACKDAYS",StipulationType_LOOKBACKDAYS_get, StipulationType_LOOKBACKDAYS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_CALLPROTECTION",StipulationType_CALLPROTECTION_get, StipulationType_CALLPROTECTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_MAXIMUMSUBSTITUTIONSREPO",StipulationType_MAXIMUMSUBSTITUTIONSREPO_get, StipulationType_MAXIMUMSUBSTITUTIONSREPO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_YEARORYEARMONTHOFISSUE",StipulationType_YEARORYEARMONTHOFISSUE_get, StipulationType_YEARORYEARMONTHOFISSUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_CONSTANTPREPAYMENTRATE",StipulationType_CONSTANTPREPAYMENTRATE_get, StipulationType_CONSTANTPREPAYMENTRATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_ISSUE_SIZE_RANGE",StipulationType_ISSUE_SIZE_RANGE_get, StipulationType_ISSUE_SIZE_RANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_WEIGHTEDAVERAGEMATURITY",StipulationType_WEIGHTEDAVERAGEMATURITY_get, StipulationType_WEIGHTEDAVERAGEMATURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_CONSTANT_PREPAYMENT_RATE",StipulationType_CONSTANT_PREPAYMENT_RATE_get, StipulationType_CONSTANT_PREPAYMENT_RATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_PERCENT_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE",StipulationType_PERCENT_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE_get, StipulationType_PERCENT_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_POOLSMINIMUM",StipulationType_POOLSMINIMUM_get, StipulationType_POOLSMINIMUM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_FINAL_CPR_OF_HOME_EQUITY_PREPAYMENT_CURVE",StipulationType_FINAL_CPR_OF_HOME_EQUITY_PREPAYMENT_CURVE_get, StipulationType_FINAL_CPR_OF_HOME_EQUITY_PREPAYMENT_CURVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_BROKERS_SALES_CREDIT",StipulationType_BROKERS_SALES_CREDIT_get, StipulationType_BROKERS_SALES_CREDIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_ORDER_QUANTITY_INCREMENT",StipulationType_ORDER_QUANTITY_INCREMENT_get, StipulationType_ORDER_QUANTITY_INCREMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_REFERENCE_TO_ROLLING_OR_CLOSING_TRADE",StipulationType_REFERENCE_TO_ROLLING_OR_CLOSING_TRADE_get, StipulationType_REFERENCE_TO_ROLLING_OR_CLOSING_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_AVAILABLE_OFFER_QUANTITY_TO_BE_SHOWN_TO_THE_STREET",StipulationType_AVAILABLE_OFFER_QUANTITY_TO_BE_SHOWN_TO_THE_STREET_get, StipulationType_AVAILABLE_OFFER_QUANTITY_TO_BE_SHOWN_TO_THE_STREET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_ISSUERS_TICKER",StipulationType_ISSUERS_TICKER_get, StipulationType_ISSUERS_TICKER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_ISOCURRENCYCODE",StipulationType_ISOCURRENCYCODE_get, StipulationType_ISOCURRENCYCODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_THE_MINIMUM_RESIDUAL_OFFER_QUANTITY",StipulationType_THE_MINIMUM_RESIDUAL_OFFER_QUANTITY_get, StipulationType_THE_MINIMUM_RESIDUAL_OFFER_QUANTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_DISCOUNT_RATE",StipulationType_DISCOUNT_RATE_get, StipulationType_DISCOUNT_RATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_VALUATIONDISCOUNT",StipulationType_VALUATIONDISCOUNT_get, StipulationType_VALUATIONDISCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_SINGLE_MONTHLY_MORTALITY",StipulationType_SINGLE_MONTHLY_MORTALITY_get, StipulationType_SINGLE_MONTHLY_MORTALITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_LOT_VARIANCE",StipulationType_LOT_VARIANCE_get, StipulationType_LOT_VARIANCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_PERCENTOFMANUFACTUREDHOUSINGPREPAYMENTCURVE",StipulationType_PERCENTOFMANUFACTUREDHOUSINGPREPAYMENTCURVE_get, StipulationType_PERCENTOFMANUFACTUREDHOUSINGPREPAYMENTCURVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_FREEFORMTEXT",StipulationType_FREEFORMTEXT_get, StipulationType_FREEFORMTEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_WHOLE_POOL",StipulationType_WHOLE_POOL_get, StipulationType_WHOLE_POOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_GEOGRAPHICS_AND_RANGE",StipulationType_GEOGRAPHICS_AND_RANGE_get, StipulationType_GEOGRAPHICS_AND_RANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_INTEREST_OF_ROLLING_OR_CLOSING_TRADE",StipulationType_INTEREST_OF_ROLLING_OR_CLOSING_TRADE_get, StipulationType_INTEREST_OF_ROLLING_OR_CLOSING_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_TRADEVARIANCEVALUEINPERCENTMAXIMUMOVERORUNDERALLOCATIONALLOWED",StipulationType_TRADEVARIANCEVALUEINPERCENTMAXIMUMOVERORUNDERALLOCATIONALLOWED_get, StipulationType_TRADEVARIANCEVALUEINPERCENTMAXIMUMOVERORUNDERALLOCATIONALLOWED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_FREEFORM_TEXT",StipulationType_FREEFORM_TEXT_get, StipulationType_FREEFORM_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_RATING_SOURCE_AND_RANGE",StipulationType_RATING_SOURCE_AND_RANGE_get, StipulationType_RATING_SOURCE_AND_RANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_OFFER_QUANTITY_TO_BE_SHOWN_TO_INTERNAL_BROKERS",StipulationType_OFFER_QUANTITY_TO_BE_SHOWN_TO_INTERNAL_BROKERS_get, StipulationType_OFFER_QUANTITY_TO_BE_SHOWN_TO_INTERNAL_BROKERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_OFFER_PRICE_TO_BE_SHOWN_TO_INTERNAL_BROKERS",StipulationType_OFFER_PRICE_TO_BE_SHOWN_TO_INTERNAL_BROKERS_get, StipulationType_OFFER_PRICE_TO_BE_SHOWN_TO_INTERNAL_BROKERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_NUMBER_OF_PIECES",StipulationType_NUMBER_OF_PIECES_get, StipulationType_NUMBER_OF_PIECES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_MINIMUM_INCREMENT",StipulationType_MINIMUM_INCREMENT_get, StipulationType_MINIMUM_INCREMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_PRODUCTIONYEAR",StipulationType_PRODUCTIONYEAR_get, StipulationType_PRODUCTIONYEAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_WEIGHTED_AVERAGE_MATURITY",StipulationType_WEIGHTED_AVERAGE_MATURITY_get, StipulationType_WEIGHTED_AVERAGE_MATURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_GEOGRAPHICS",StipulationType_GEOGRAPHICS_get, StipulationType_GEOGRAPHICS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_MINIMUMQUANTITY",StipulationType_MINIMUMQUANTITY_get, StipulationType_MINIMUMQUANTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_POOL_IDENTIFIER",StipulationType_POOL_IDENTIFIER_get, StipulationType_POOL_IDENTIFIER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_MATURITY_YEAR_AND_MONTH",StipulationType_MATURITY_YEAR_AND_MONTH_get, StipulationType_MATURITY_YEAR_AND_MONTH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_PRICINGFREQUENCY",StipulationType_PRICINGFREQUENCY_get, StipulationType_PRICINGFREQUENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_SECURITYTYPEINCLUDEDOREXCLUDED",StipulationType_SECURITYTYPEINCLUDEDOREXCLUDED_get, StipulationType_SECURITYTYPEINCLUDEDOREXCLUDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_EXPLICITLOTIDENTIFIER",StipulationType_EXPLICITLOTIDENTIFIER_get, StipulationType_EXPLICITLOTIDENTIFIER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_MAXIMUM_SUBSTITUTIONS",StipulationType_MAXIMUM_SUBSTITUTIONS_get, StipulationType_MAXIMUM_SUBSTITUTIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_PRIMARY_OR_SECONDARY_MARKET_INDICATOR",StipulationType_PRIMARY_OR_SECONDARY_MARKET_INDICATOR_get, StipulationType_PRIMARY_OR_SECONDARY_MARKET_INDICATOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_WEIGHTEDAVERAGELOANAGE",StipulationType_WEIGHTEDAVERAGELOANAGE_get, StipulationType_WEIGHTEDAVERAGELOANAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_BENCHMARK_PRICE_SOURCE",StipulationType_BENCHMARK_PRICE_SOURCE_get, StipulationType_BENCHMARK_PRICE_SOURCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_MINIMUMDENOMINATION",StipulationType_MINIMUMDENOMINATION_get, StipulationType_MINIMUMDENOMINATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_YEAR_OR_YEAR_MONTH_OF_ISSUE",StipulationType_YEAR_OR_YEAR_MONTH_OF_ISSUE_get, StipulationType_YEAR_OR_YEAR_MONTH_OF_ISSUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_PAYMENTFREQUENCYCALENDAR",StipulationType_PAYMENTFREQUENCYCALENDAR_get, StipulationType_PAYMENTFREQUENCYCALENDAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_POOLS_MAXIMUM",StipulationType_POOLS_MAXIMUM_get, StipulationType_POOLS_MAXIMUM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_SUBSTITUTIONS_FREQUENCY",StipulationType_SUBSTITUTIONS_FREQUENCY_get, StipulationType_SUBSTITUTIONS_FREQUENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_BENCHMARKPRICESOURCE",StipulationType_BENCHMARKPRICESOURCE_get, StipulationType_BENCHMARKPRICESOURCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_ABSOLUTEPREPAYMENTSPEED",StipulationType_ABSOLUTEPREPAYMENTSPEED_get, StipulationType_ABSOLUTEPREPAYMENTSPEED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_BANKQUALIFIED",StipulationType_BANKQUALIFIED_get, StipulationType_BANKQUALIFIED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_YIELDRANGE",StipulationType_YIELDRANGE_get, StipulationType_YIELDRANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_BARGAINCONDITIONS",StipulationType_BARGAINCONDITIONS_get, StipulationType_BARGAINCONDITIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_MONTHLYPREPAYMENTRATE",StipulationType_MONTHLYPREPAYMENTRATE_get, StipulationType_MONTHLYPREPAYMENTRATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_POOLSPERLOT",StipulationType_POOLSPERLOT_get, StipulationType_POOLSPERLOT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_CONSTANT_PREPAYMENT_YIELD",StipulationType_CONSTANT_PREPAYMENT_YIELD_get, StipulationType_CONSTANT_PREPAYMENT_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_MINIMUM_DENOMINATION",StipulationType_MINIMUM_DENOMINATION_get, StipulationType_MINIMUM_DENOMINATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_ALTERNATIVE_MINIMUM_TAX",StipulationType_ALTERNATIVE_MINIMUM_TAX_get, StipulationType_ALTERNATIVE_MINIMUM_TAX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_CUSTOMSTARTENDDATE",StipulationType_CUSTOMSTARTENDDATE_get, StipulationType_CUSTOMSTARTENDDATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_TYPEOFREDEMPTIONVALUESARE",StipulationType_TYPEOFREDEMPTIONVALUESARE_get, StipulationType_TYPEOFREDEMPTIONVALUESARE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_PERCENT_OF_BMA_PREPAYMENT_CURVE",StipulationType_PERCENT_OF_BMA_PREPAYMENT_CURVE_get, StipulationType_PERCENT_OF_BMA_PREPAYMENT_CURVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_NUMBEROFPIECES",StipulationType_NUMBEROFPIECES_get, StipulationType_NUMBEROFPIECES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_AMT",StipulationType_AMT_get, StipulationType_AMT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_CONSTANTPREPAYMENTPENALTY",StipulationType_CONSTANTPREPAYMENTPENALTY_get, StipulationType_CONSTANTPREPAYMENTPENALTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_MAXIMUM_ORDER_SIZE",StipulationType_MAXIMUM_ORDER_SIZE_get, StipulationType_MAXIMUM_ORDER_SIZE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_AUTOREINVESTMENTATRATEORBETTER",StipulationType_AUTOREINVESTMENTATRATEORBETTER_get, StipulationType_AUTOREINVESTMENTATRATEORBETTER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_BARGAIN_CONDITIONS",StipulationType_BARGAIN_CONDITIONS_get, StipulationType_BARGAIN_CONDITIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_GEOGRAPHICSANDRANGE",StipulationType_GEOGRAPHICSANDRANGE_get, StipulationType_GEOGRAPHICSANDRANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_LOTVARIANCEVALUEINPERCENTMAXIMUMOVERORUNDERALLOCATIONALLOWED",StipulationType_LOTVARIANCEVALUEINPERCENTMAXIMUMOVERORUNDERALLOCATIONALLOWED_get, StipulationType_LOTVARIANCEVALUEINPERCENTMAXIMUMOVERORUNDERALLOCATIONALLOWED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_TYPE_OF_ROLL_TRADE",StipulationType_TYPE_OF_ROLL_TRADE_get, StipulationType_TYPE_OF_ROLL_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_PRINCIPAL_OF_ROLLING_OR_CLOSING_TRADE",StipulationType_PRINCIPAL_OF_ROLLING_OR_CLOSING_TRADE_get, StipulationType_PRINCIPAL_OF_ROLLING_OR_CLOSING_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_PERCENT_OF_PROSPECTUS_PREPAYMENT_CURVE",StipulationType_PERCENT_OF_PROSPECTUS_PREPAYMENT_CURVE_get, StipulationType_PERCENT_OF_PROSPECTUS_PREPAYMENT_CURVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_WEIGHTED_AVERAGE_COUPON",StipulationType_WEIGHTED_AVERAGE_COUPON_get, StipulationType_WEIGHTED_AVERAGE_COUPON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_AUTO_REINVESTMENT_AT_RATE_OR_BETTER",StipulationType_AUTO_REINVESTMENT_AT_RATE_OR_BETTER_get, StipulationType_AUTO_REINVESTMENT_AT_RATE_OR_BETTER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_STRUCTURE",StipulationType_STRUCTURE_get, StipulationType_STRUCTURE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_WHOLEPOOL",StipulationType_WHOLEPOOL_get, StipulationType_WHOLEPOOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_MARKET_SECTOR",StipulationType_MARKET_SECTOR_get, StipulationType_MARKET_SECTOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_MATURITY_RANGE",StipulationType_MATURITY_RANGE_get, StipulationType_MATURITY_RANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_SECURITY_TYPE_INCLUDED_OR_EXCLUDED",StipulationType_SECURITY_TYPE_INCLUDED_OR_EXCLUDED_get, StipulationType_SECURITY_TYPE_INCLUDED_OR_EXCLUDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_POOLSPERMILLION",StipulationType_POOLSPERMILLION_get, StipulationType_POOLSPERMILLION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_TRADE_VARIANCE",StipulationType_TRADE_VARIANCE_get, StipulationType_TRADE_VARIANCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_ISSUERSTICKER",StipulationType_ISSUERSTICKER_get, StipulationType_ISSUERSTICKER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_PRICERANGE",StipulationType_PRICERANGE_get, StipulationType_PRICERANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_LOOKBACK_DAYS",StipulationType_LOOKBACK_DAYS_get, StipulationType_LOOKBACK_DAYS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE",StipulationType_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE_get, StipulationType_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_POOLS_PER_MILLION",StipulationType_POOLS_PER_MILLION_get, StipulationType_POOLS_PER_MILLION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_MINIMUMINCREMENT",StipulationType_MINIMUMINCREMENT_get, StipulationType_MINIMUMINCREMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_MATURITY_YEAR",StipulationType_MATURITY_YEAR_get, StipulationType_MATURITY_YEAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_RATINGSOURCEANDRANGE",StipulationType_RATINGSOURCEANDRANGE_get, StipulationType_RATINGSOURCEANDRANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_AVERAGE_LOAN_SIZE",StipulationType_AVERAGE_LOAN_SIZE_get, StipulationType_AVERAGE_LOAN_SIZE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_PURPOSE",StipulationType_PURPOSE_get, StipulationType_PURPOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_ISO_CURRENCY_CODE",StipulationType_ISO_CURRENCY_CODE_get, StipulationType_ISO_CURRENCY_CODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_RESTRICTED",StipulationType_RESTRICTED_get, StipulationType_RESTRICTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_BROKER_SALES_CREDIT_OVERRIDE",StipulationType_BROKER_SALES_CREDIT_OVERRIDE_get, StipulationType_BROKER_SALES_CREDIT_OVERRIDE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON",StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON_get, StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_WEIGHTEDAVERAGECOUPON",StipulationType_WEIGHTEDAVERAGECOUPON_get, StipulationType_WEIGHTEDAVERAGECOUPON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_OF_PROSPECTUS_PREPAYMENT_CURVE",StipulationType_OF_PROSPECTUS_PREPAYMENT_CURVE_get, StipulationType_OF_PROSPECTUS_PREPAYMENT_CURVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_ISSUESIZERANGE",StipulationType_ISSUESIZERANGE_get, StipulationType_ISSUESIZERANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_YEAR_OF_ISSUE",StipulationType_YEAR_OF_ISSUE_get, StipulationType_YEAR_OF_ISSUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_WEIGHTEDAVERAGELIFECOUPON",StipulationType_WEIGHTEDAVERAGELIFECOUPON_get, StipulationType_WEIGHTEDAVERAGELIFECOUPON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_PAYMENT_FREQUENCY_CALENDAR",StipulationType_PAYMENT_FREQUENCY_CALENDAR_get, StipulationType_PAYMENT_FREQUENCY_CALENDAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_TRADERS_CREDIT",StipulationType_TRADERS_CREDIT_get, StipulationType_TRADERS_CREDIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_MINIMUM_QUANTITY",StipulationType_MINIMUM_QUANTITY_get, StipulationType_MINIMUM_QUANTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_SUBSTITUTIONS_LEFT",StipulationType_SUBSTITUTIONS_LEFT_get, StipulationType_SUBSTITUTIONS_LEFT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_POOLS_PER_TRADE",StipulationType_POOLS_PER_TRADE_get, StipulationType_POOLS_PER_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_TYPE_OF_REDEMPTION",StipulationType_TYPE_OF_REDEMPTION_get, StipulationType_TYPE_OF_REDEMPTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_CONSTANT_PREPAYMENT_PENALTY",StipulationType_CONSTANT_PREPAYMENT_PENALTY_get, StipulationType_CONSTANT_PREPAYMENT_PENALTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_WEIGHTED_AVERAGE_LOAN_AGE",StipulationType_WEIGHTED_AVERAGE_LOAN_AGE_get, StipulationType_WEIGHTED_AVERAGE_LOAN_AGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_PRICE_RANGE",StipulationType_PRICE_RANGE_get, StipulationType_PRICE_RANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_SUBSTITUTIONSFREQUENCYREPO",StipulationType_SUBSTITUTIONSFREQUENCYREPO_get, StipulationType_SUBSTITUTIONSFREQUENCYREPO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_PRODUCTION_YEAR",StipulationType_PRODUCTION_YEAR_get, StipulationType_PRODUCTION_YEAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_SINGLEMONTHLYMORTALITY",StipulationType_SINGLEMONTHLYMORTALITY_get, StipulationType_SINGLEMONTHLYMORTALITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_OF_BMA_PREPAYMENT_CURVE",StipulationType_OF_BMA_PREPAYMENT_CURVE_get, StipulationType_OF_BMA_PREPAYMENT_CURVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_EXPLICIT_LOT_IDENTIFIER",StipulationType_EXPLICIT_LOT_IDENTIFIER_get, StipulationType_EXPLICIT_LOT_IDENTIFIER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_ABSOLUTE_PREPAYMENT_SPEED",StipulationType_ABSOLUTE_PREPAYMENT_SPEED_get, StipulationType_ABSOLUTE_PREPAYMENT_SPEED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_MAXIMUMDENOMINATION",StipulationType_MAXIMUMDENOMINATION_get, StipulationType_MAXIMUMDENOMINATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_PERCENTOFPROSPECTUSPREPAYMENTCURVE",StipulationType_PERCENTOFPROSPECTUSPREPAYMENTCURVE_get, StipulationType_PERCENTOFPROSPECTUSPREPAYMENTCURVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_VALUATION_DISCOUNT",StipulationType_VALUATION_DISCOUNT_get, StipulationType_VALUATION_DISCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_YIELD_TO_MATURITY",StipulationType_YIELD_TO_MATURITY_get, StipulationType_YIELD_TO_MATURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_WEIGHTED_AVERAGE_LIFE",StipulationType_WEIGHTED_AVERAGE_LIFE_get, StipulationType_WEIGHTED_AVERAGE_LIFE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_POOLSMAXIMUM",StipulationType_POOLSMAXIMUM_get, StipulationType_POOLSMAXIMUM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_YIELD_RANGE",StipulationType_YIELD_RANGE_get, StipulationType_YIELD_RANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_PRICING_FREQUENCY",StipulationType_PRICING_FREQUENCY_get, StipulationType_PRICING_FREQUENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_POOLSPERTRADE",StipulationType_POOLSPERTRADE_get, StipulationType_POOLSPERTRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_MONTHLY_PREPAYMENT_RATE",StipulationType_MONTHLY_PREPAYMENT_RATE_get, StipulationType_MONTHLY_PREPAYMENT_RATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_COUPONRANGE",StipulationType_COUPONRANGE_get, StipulationType_COUPONRANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_MARKETSECTOR",StipulationType_MARKETSECTOR_get, StipulationType_MARKETSECTOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_AVERAGE_FICO_SCORE",StipulationType_AVERAGE_FICO_SCORE_get, StipulationType_AVERAGE_FICO_SCORE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_INSURED",StipulationType_INSURED_get, StipulationType_INSURED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_BANK_QUALIFIED",StipulationType_BANK_QUALIFIED_get, StipulationType_BANK_QUALIFIED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceQuoteMethod_STANDARD",PriceQuoteMethod_STANDARD_get, PriceQuoteMethod_STANDARD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceQuoteMethod_PERCENT_OF_PAR",PriceQuoteMethod_PERCENT_OF_PAR_get, PriceQuoteMethod_PERCENT_OF_PAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceQuoteMethod_INDEX",PriceQuoteMethod_INDEX_get, PriceQuoteMethod_INDEX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceQuoteMethod_INTEREST_RATE_INDEX",PriceQuoteMethod_INTEREST_RATE_INDEX_get, PriceQuoteMethod_INTEREST_RATE_INDEX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_REQUIREDTAGMISSING",SessionRejectReason_REQUIREDTAGMISSING_get, SessionRejectReason_REQUIREDTAGMISSING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_TAGSPECIFIEDOUTOFREQUIREDORDER",SessionRejectReason_TAGSPECIFIEDOUTOFREQUIREDORDER_get, SessionRejectReason_TAGSPECIFIEDOUTOFREQUIREDORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_NON_DATA_VALUE_INCLUDES_FIELD_DELIMITER",SessionRejectReason_NON_DATA_VALUE_INCLUDES_FIELD_DELIMITER_get, SessionRejectReason_NON_DATA_VALUE_INCLUDES_FIELD_DELIMITER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_INVALIDTAGNUMBER",SessionRejectReason_INVALIDTAGNUMBER_get, SessionRejectReason_INVALIDTAGNUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_VALUEISINCORRECTOUTOFRANGEFORTHISTAG",SessionRejectReason_VALUEISINCORRECTOUTOFRANGEFORTHISTAG_get, SessionRejectReason_VALUEISINCORRECTOUTOFRANGEFORTHISTAG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_COMPID_PROBLEM",SessionRejectReason_COMPID_PROBLEM_get, SessionRejectReason_COMPID_PROBLEM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_SENDINGTIMEACCURACYPROBLEM",SessionRejectReason_SENDINGTIMEACCURACYPROBLEM_get, SessionRejectReason_SENDINGTIMEACCURACYPROBLEM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_SIGNATURE_PROBLEM",SessionRejectReason_SIGNATURE_PROBLEM_get, SessionRejectReason_SIGNATURE_PROBLEM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE",SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_get, SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_UNDEFINEDTAG",SessionRejectReason_UNDEFINEDTAG_get, SessionRejectReason_UNDEFINEDTAG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_XML_VALIDATION_ERROR",SessionRejectReason_XML_VALIDATION_ERROR_get, SessionRejectReason_XML_VALIDATION_ERROR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_NONDATAVALUEINCLUDESFIELDDELIMITERSOHCHARACTER",SessionRejectReason_NONDATAVALUEINCLUDESFIELDDELIMITERSOHCHARACTER_get, SessionRejectReason_NONDATAVALUEINCLUDESFIELDDELIMITERSOHCHARACTER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_UNDEFINED_TAG",SessionRejectReason_UNDEFINED_TAG_get, SessionRejectReason_UNDEFINED_TAG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_TAGAPPEARSMORETHANONCE",SessionRejectReason_TAGAPPEARSMORETHANONCE_get, SessionRejectReason_TAGAPPEARSMORETHANONCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE",SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_get, SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_REPEATING_GROUP_FIELDS_OUT_OF_ORDER",SessionRejectReason_REPEATING_GROUP_FIELDS_OUT_OF_ORDER_get, SessionRejectReason_REPEATING_GROUP_FIELDS_OUT_OF_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_REQUIRED_TAG_MISSING",SessionRejectReason_REQUIRED_TAG_MISSING_get, SessionRejectReason_REQUIRED_TAG_MISSING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_INVALIDMSGTYPE",SessionRejectReason_INVALIDMSGTYPE_get, SessionRejectReason_INVALIDMSGTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_XMLVALIDATIONERROR",SessionRejectReason_XMLVALIDATIONERROR_get, SessionRejectReason_XMLVALIDATIONERROR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_REPEATINGGROUPFIELDSOUTOFORDER",SessionRejectReason_REPEATINGGROUPFIELDSOUTOFORDER_get, SessionRejectReason_REPEATINGGROUPFIELDSOUTOFORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_INCORRECTNUMINGROUPCOUNTFORREPEATINGGROUP",SessionRejectReason_INCORRECTNUMINGROUPCOUNTFORREPEATINGGROUP_get, SessionRejectReason_INCORRECTNUMINGROUPCOUNTFORREPEATINGGROUP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_TAGSPECIFIEDWITHOUTAVALUE",SessionRejectReason_TAGSPECIFIEDWITHOUTAVALUE_get, SessionRejectReason_TAGSPECIFIEDWITHOUTAVALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_DECRYPTIONPROBLEM",SessionRejectReason_DECRYPTIONPROBLEM_get, SessionRejectReason_DECRYPTIONPROBLEM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_INCORRECTDATAFORMATFORVALUE",SessionRejectReason_INCORRECTDATAFORMATFORVALUE_get, SessionRejectReason_INCORRECTDATAFORMATFORVALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_OTHER",SessionRejectReason_OTHER_get, SessionRejectReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP",SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_get, SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE",SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_get, SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_COMPIDPROBLEM",SessionRejectReason_COMPIDPROBLEM_get, SessionRejectReason_COMPIDPROBLEM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER",SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_get, SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_SIGNATUREPROBLEM",SessionRejectReason_SIGNATUREPROBLEM_get, SessionRejectReason_SIGNATUREPROBLEM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_DECRYPTION_PROBLEM",SessionRejectReason_DECRYPTION_PROBLEM_get, SessionRejectReason_DECRYPTION_PROBLEM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_INVALID_TAG_NUMBER",SessionRejectReason_INVALID_TAG_NUMBER_get, SessionRejectReason_INVALID_TAG_NUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_TAGNOTDEFINEDFORTHISMESSAGETYPE",SessionRejectReason_TAGNOTDEFINEDFORTHISMESSAGETYPE_get, SessionRejectReason_TAGNOTDEFINEDFORTHISMESSAGETYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_VALUE_IS_INCORRECT",SessionRejectReason_VALUE_IS_INCORRECT_get, SessionRejectReason_VALUE_IS_INCORRECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE",SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_get, SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_INVALID_MSGTYPE",SessionRejectReason_INVALID_MSGTYPE_get, SessionRejectReason_INVALID_MSGTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM",SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_get, SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeliveryType_TRI_PARTY",DeliveryType_TRI_PARTY_get, DeliveryType_TRI_PARTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeliveryType_HOLD_IN_CUSTODY",DeliveryType_HOLD_IN_CUSTODY_get, DeliveryType_HOLD_IN_CUSTODY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeliveryType_FREE",DeliveryType_FREE_get, DeliveryType_FREE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeliveryType_HOLDINCUSTODY",DeliveryType_HOLDINCUSTODY_get, DeliveryType_HOLDINCUSTODY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeliveryType_VERSUSPAYMENT",DeliveryType_VERSUSPAYMENT_get, DeliveryType_VERSUSPAYMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeliveryType_VERSUS_PAYMENT_DELIVER",DeliveryType_VERSUS_PAYMENT_DELIVER_get, DeliveryType_VERSUS_PAYMENT_DELIVER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeliveryType_FREE_DELIVER",DeliveryType_FREE_DELIVER_get, DeliveryType_FREE_DELIVER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeliveryType_TRIPARTY",DeliveryType_TRIPARTY_get, DeliveryType_TRIPARTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Scope_LOCAL",Scope_LOCAL_get, Scope_LOCAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Scope_LOCAL_MARKET",Scope_LOCAL_MARKET_get, Scope_LOCAL_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Scope_GLOBAL",Scope_GLOBAL_get, Scope_GLOBAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Scope_NATIONAL",Scope_NATIONAL_get, Scope_NATIONAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Scope_LOCALMARKET",Scope_LOCALMARKET_get, Scope_LOCALMARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeleteReason_CANCELLATION",DeleteReason_CANCELLATION_get, DeleteReason_CANCELLATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeleteReason_CANCELTRADEBUST",DeleteReason_CANCELTRADEBUST_get, DeleteReason_CANCELTRADEBUST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeleteReason_CANCELATION",DeleteReason_CANCELATION_get, DeleteReason_CANCELATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeleteReason_ERROR",DeleteReason_ERROR_get, DeleteReason_ERROR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InViewOfCommon_NO",InViewOfCommon_NO_get, InViewOfCommon_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InViewOfCommon_YES",InViewOfCommon_YES_get, InViewOfCommon_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NoSides_BOTHSIDES",NoSides_BOTHSIDES_get, NoSides_BOTHSIDES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NoSides_ONESIDE",NoSides_ONESIDE_get, NoSides_ONESIDE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NoSides_ONE_SIDE",NoSides_ONE_SIDE_get, NoSides_ONE_SIDE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NoSides_BOTH_SIDES",NoSides_BOTH_SIDES_get, NoSides_BOTH_SIDES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_TERM_LIQUIDITY_NOTE",SecurityType_TERM_LIQUIDITY_NOTE_get, SecurityType_TERM_LIQUIDITY_NOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_TO_BE_ANNOUNCED",SecurityType_TO_BE_ANNOUNCED_get, SecurityType_TO_BE_ANNOUNCED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_REVERSE_REPURCHASE_AGREEMENT",SecurityType_REVERSE_REPURCHASE_AGREEMENT_get, SecurityType_REVERSE_REPURCHASE_AGREEMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_BRADY_BOND",SecurityType_BRADY_BOND_get, SecurityType_BRADY_BOND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_TREASURYINFLATIONPROTECTEDSECURITIES",SecurityType_TREASURYINFLATIONPROTECTEDSECURITIES_get, SecurityType_TREASURYINFLATIONPROTECTEDSECURITIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CORP_MORTGAGE_BACKED_SECURITIES",SecurityType_CORP_MORTGAGE_BACKED_SECURITIES_get, SecurityType_CORP_MORTGAGE_BACKED_SECURITIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CERTIFICATE_OF_PARTICIPATION",SecurityType_CERTIFICATE_OF_PARTICIPATION_get, SecurityType_CERTIFICATE_OF_PARTICIPATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_BUY_SELLBACK",SecurityType_BUY_SELLBACK_get, SecurityType_BUY_SELLBACK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_OPTIONS_ON_COMBO",SecurityType_OPTIONS_ON_COMBO_get, SecurityType_OPTIONS_ON_COMBO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MULTILEG_INSTRUMENT",SecurityType_MULTILEG_INSTRUMENT_get, SecurityType_MULTILEG_INSTRUMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_TAX_ALLOCATION",SecurityType_TAX_ALLOCATION_get, SecurityType_TAX_ALLOCATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_US_TREASURY_NOTE_BOND",SecurityType_US_TREASURY_NOTE_BOND_get, SecurityType_US_TREASURY_NOTE_BOND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_REVENUE_ANTICIPATION_NOTE",SecurityType_REVENUE_ANTICIPATION_NOTE_get, SecurityType_REVENUE_ANTICIPATION_NOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_YANKEECERTIFICATEOFDEPOSIT",SecurityType_YANKEECERTIFICATEOFDEPOSIT_get, SecurityType_YANKEECERTIFICATEOFDEPOSIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MEDIUMTERMNOTES",SecurityType_MEDIUMTERMNOTES_get, SecurityType_MEDIUMTERMNOTES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_SPECIAL_TAX",SecurityType_SPECIAL_TAX_get, SecurityType_SPECIAL_TAX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_PRIVATE_EXPORT_FUNDING",SecurityType_PRIVATE_EXPORT_FUNDING_get, SecurityType_PRIVATE_EXPORT_FUNDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_EUROCERTIFICATEOFDEPOSIT",SecurityType_EUROCERTIFICATEOFDEPOSIT_get, SecurityType_EUROCERTIFICATEOFDEPOSIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_SPECIAL_OBLIGATION",SecurityType_SPECIAL_OBLIGATION_get, SecurityType_SPECIAL_OBLIGATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_FX_SWAP",SecurityType_FX_SWAP_get, SecurityType_FX_SWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_REVOLVER_TERM_LOAN",SecurityType_REVOLVER_TERM_LOAN_get, SecurityType_REVOLVER_TERM_LOAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_TAXEXEMPTCOMMERCIALPAPER",SecurityType_TAXEXEMPTCOMMERCIALPAPER_get, SecurityType_TAXEXEMPTCOMMERCIALPAPER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_REVOLVER_LOAN",SecurityType_REVOLVER_LOAN_get, SecurityType_REVOLVER_LOAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CASH",SecurityType_CASH_get, SecurityType_CASH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_USTREASURYNOTEDEPRECATEDVALUEUSETNOTE",SecurityType_USTREASURYNOTEDEPRECATEDVALUEUSETNOTE_get, SecurityType_USTREASURYNOTEDEPRECATEDVALUEUSETNOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MISCELLANEOUS_PASS_THRU",SecurityType_MISCELLANEOUS_PASS_THRU_get, SecurityType_MISCELLANEOUS_PASS_THRU_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CONVERTIBLEBOND",SecurityType_CONVERTIBLEBOND_get, SecurityType_CONVERTIBLEBOND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_VARIABLE_RATE_DEMAND_NOTE",SecurityType_VARIABLE_RATE_DEMAND_NOTE_get, SecurityType_VARIABLE_RATE_DEMAND_NOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MULTILEGINSTRUMENT",SecurityType_MULTILEGINSTRUMENT_get, SecurityType_MULTILEGINSTRUMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_FEDERAL_AGENCY_DISCOUNT_NOTE",SecurityType_FEDERAL_AGENCY_DISCOUNT_NOTE_get, SecurityType_FEDERAL_AGENCY_DISCOUNT_NOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_SPECIALOBLIGATION",SecurityType_SPECIALOBLIGATION_get, SecurityType_SPECIALOBLIGATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CANADIAN_TREASURY_BILLS",SecurityType_CANADIAN_TREASURY_BILLS_get, SecurityType_CANADIAN_TREASURY_BILLS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_REVENUEANTICIPATIONNOTE",SecurityType_REVENUEANTICIPATIONNOTE_get, SecurityType_REVENUEANTICIPATIONNOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CERTIFICATEOFOBLIGATION",SecurityType_CERTIFICATEOFOBLIGATION_get, SecurityType_CERTIFICATEOFOBLIGATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_INDEXEDLINKED",SecurityType_INDEXEDLINKED_get, SecurityType_INDEXEDLINKED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_LETTER_OF_CREDIT",SecurityType_LETTER_OF_CREDIT_get, SecurityType_LETTER_OF_CREDIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MANDATORYTENDER",SecurityType_MANDATORYTENDER_get, SecurityType_MANDATORYTENDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_USTREASURYBOND",SecurityType_USTREASURYBOND_get, SecurityType_USTREASURYBOND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_TERMLOAN",SecurityType_TERMLOAN_get, SecurityType_TERMLOAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_OPTIONS_ON_FUTURES",SecurityType_OPTIONS_ON_FUTURES_get, SecurityType_OPTIONS_ON_FUTURES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_PROMISSORYNOTE",SecurityType_PROMISSORYNOTE_get, SecurityType_PROMISSORYNOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_DUAL_CURRENCY",SecurityType_DUAL_CURRENCY_get, SecurityType_DUAL_CURRENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_WILDCARD_ENTRY",SecurityType_WILDCARD_ENTRY_get, SecurityType_WILDCARD_ENTRY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_BANK_DEPOSITORY_NOTE",SecurityType_BANK_DEPOSITORY_NOTE_get, SecurityType_BANK_DEPOSITORY_NOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_REPLACED",SecurityType_REPLACED_get, SecurityType_REPLACED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MORTGAGE_PRINCIPAL_ONLY",SecurityType_MORTGAGE_PRINCIPAL_ONLY_get, SecurityType_MORTGAGE_PRINCIPAL_ONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CANADIAN_TREASURY_NOTES",SecurityType_CANADIAN_TREASURY_NOTES_get, SecurityType_CANADIAN_TREASURY_NOTES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_USTREASURYBILLDEPRECATEDVALUEUSETBILL",SecurityType_USTREASURYBILLDEPRECATEDVALUEUSETBILL_get, SecurityType_USTREASURYBILLDEPRECATEDVALUEUSETBILL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_TOBEANNOUNCED",SecurityType_TOBEANNOUNCED_get, SecurityType_TOBEANNOUNCED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_SECURITIES_PLEDGE",SecurityType_SECURITIES_PLEDGE_get, SecurityType_SECURITIES_PLEDGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_YANKEE_CORPORATE_BOND",SecurityType_YANKEE_CORPORATE_BOND_get, SecurityType_YANKEE_CORPORATE_BOND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_FX_SPOT",SecurityType_FX_SPOT_get, SecurityType_FX_SPOT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_LIQUIDITYNOTE",SecurityType_LIQUIDITYNOTE_get, SecurityType_LIQUIDITYNOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_OVERNIGHT",SecurityType_OVERNIGHT_get, SecurityType_OVERNIGHT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MORTGAGE_INTEREST_ONLY",SecurityType_MORTGAGE_INTEREST_ONLY_get, SecurityType_MORTGAGE_INTEREST_ONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_BRIDGELOAN",SecurityType_BRIDGELOAN_get, SecurityType_BRIDGELOAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_OTHER_ANTICIPATION_NOTES_BAN_GAN_ETC",SecurityType_OTHER_ANTICIPATION_NOTES_BAN_GAN_ETC_get, SecurityType_OTHER_ANTICIPATION_NOTES_BAN_GAN_ETC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_EXTENDED_COMM_NOTE",SecurityType_EXTENDED_COMM_NOTE_get, SecurityType_EXTENDED_COMM_NOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CERTIFICATEOFPARTICIPATION",SecurityType_CERTIFICATEOFPARTICIPATION_get, SecurityType_CERTIFICATEOFPARTICIPATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CATS_TIGERS_LIONS",SecurityType_CATS_TIGERS_LIONS_get, SecurityType_CATS_TIGERS_LIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_FORWARD",SecurityType_FORWARD_get, SecurityType_FORWARD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_YANKEE_CERTIFICATE_OF_DEPOSIT",SecurityType_YANKEE_CERTIFICATE_OF_DEPOSIT_get, SecurityType_YANKEE_CERTIFICATE_OF_DEPOSIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_PREFERRED_STOCK",SecurityType_PREFERRED_STOCK_get, SecurityType_PREFERRED_STOCK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_US_TREASURY_BOND",SecurityType_US_TREASURY_BOND_get, SecurityType_US_TREASURY_BOND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_TREASURY_INFLATION_PROTECTED_SECURITIES",SecurityType_TREASURY_INFLATION_PROTECTED_SECURITIES_get, SecurityType_TREASURY_INFLATION_PROTECTED_SECURITIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_BUYSELLBACK",SecurityType_BUYSELLBACK_get, SecurityType_BUYSELLBACK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_OPTIONS_ON_PHYSICAL",SecurityType_OPTIONS_ON_PHYSICAL_get, SecurityType_OPTIONS_ON_PHYSICAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_ASSETBACKEDSECURITIES",SecurityType_ASSETBACKEDSECURITIES_get, SecurityType_ASSETBACKEDSECURITIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_NON_DELIVERABLE_FORWARD",SecurityType_NON_DELIVERABLE_FORWARD_get, SecurityType_NON_DELIVERABLE_FORWARD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MORTGAGE_PRINCIPLE_ONLY",SecurityType_MORTGAGE_PRINCIPLE_ONLY_get, SecurityType_MORTGAGE_PRINCIPLE_ONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MORTGAGE_IOETTE",SecurityType_MORTGAGE_IOETTE_get, SecurityType_MORTGAGE_IOETTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_USD_SUPRANATIONAL_COUPONS",SecurityType_USD_SUPRANATIONAL_COUPONS_get, SecurityType_USD_SUPRANATIONAL_COUPONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_WARRANT",SecurityType_WARRANT_get, SecurityType_WARRANT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_FOREIGN_EXCHANGE_CONTRACT",SecurityType_FOREIGN_EXCHANGE_CONTRACT_get, SecurityType_FOREIGN_EXCHANGE_CONTRACT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_FOREIGNEXCHANGECONTRACT",SecurityType_FOREIGNEXCHANGECONTRACT_get, SecurityType_FOREIGNEXCHANGECONTRACT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_EURO_CORPORATE_FLOATING_RATE_NOTES",SecurityType_EURO_CORPORATE_FLOATING_RATE_NOTES_get, SecurityType_EURO_CORPORATE_FLOATING_RATE_NOTES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_SPECIAL_ASSESSMENT",SecurityType_SPECIAL_ASSESSMENT_get, SecurityType_SPECIAL_ASSESSMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_EUROSUPRANATIONALCOUPONS",SecurityType_EUROSUPRANATIONALCOUPONS_get, SecurityType_EUROSUPRANATIONALCOUPONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_DEBTOR_IN_POSSESSION",SecurityType_DEBTOR_IN_POSSESSION_get, SecurityType_DEBTOR_IN_POSSESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CANADIAN_MONEY_MARKETS",SecurityType_CANADIAN_MONEY_MARKETS_get, SecurityType_CANADIAN_MONEY_MARKETS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MORTGAGEPRINCIPALONLY",SecurityType_MORTGAGEPRINCIPALONLY_get, SecurityType_MORTGAGEPRINCIPALONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_USTREASURYNOTE",SecurityType_USTREASURYNOTE_get, SecurityType_USTREASURYNOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_DEBTORINPOSSESSION",SecurityType_DEBTORINPOSSESSION_get, SecurityType_DEBTORINPOSSESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_REVENUEBONDS",SecurityType_REVENUEBONDS_get, SecurityType_REVENUEBONDS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MORTGAGEINTERESTONLY",SecurityType_MORTGAGEINTERESTONLY_get, SecurityType_MORTGAGEINTERESTONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_DEPOSITNOTES",SecurityType_DEPOSITNOTES_get, SecurityType_DEPOSITNOTES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_PRINCIPAL_STRIP_OF_A_CALLABLE_BOND_OR_NOTE",SecurityType_PRINCIPAL_STRIP_OF_A_CALLABLE_BOND_OR_NOTE_get, SecurityType_PRINCIPAL_STRIP_OF_A_CALLABLE_BOND_OR_NOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MORTGAGEPRIVATEPLACEMENT",SecurityType_MORTGAGEPRIVATEPLACEMENT_get, SecurityType_MORTGAGEPRIVATEPLACEMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_NO_SECURITY_TYPE",SecurityType_NO_SECURITY_TYPE_get, SecurityType_NO_SECURITY_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_SPECIALASSESSMENT",SecurityType_SPECIALASSESSMENT_get, SecurityType_SPECIALASSESSMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_LETTEROFCREDIT",SecurityType_LETTEROFCREDIT_get, SecurityType_LETTEROFCREDIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_TAXALLOCATION",SecurityType_TAXALLOCATION_get, SecurityType_TAXALLOCATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_TAXABLE_MUNICIPAL_CP",SecurityType_TAXABLE_MUNICIPAL_CP_get, SecurityType_TAXABLE_MUNICIPAL_CP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_OPTION",SecurityType_OPTION_get, SecurityType_OPTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_NOSECURITYTYPE",SecurityType_NOSECURITYTYPE_get, SecurityType_NOSECURITYTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_PROMISSORY_NOTE",SecurityType_PROMISSORY_NOTE_get, SecurityType_PROMISSORY_NOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_COLLATERALIZEDMORTGAGEOBLIGATION",SecurityType_COLLATERALIZEDMORTGAGEOBLIGATION_get, SecurityType_COLLATERALIZEDMORTGAGEOBLIGATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_DUALCURRENCY",SecurityType_DUALCURRENCY_get, SecurityType_DUALCURRENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CREDIT_DEFAULT_SWAP",SecurityType_CREDIT_DEFAULT_SWAP_get, SecurityType_CREDIT_DEFAULT_SWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_TAXANTICIPATIONNOTE",SecurityType_TAXANTICIPATIONNOTE_get, SecurityType_TAXANTICIPATIONNOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MORTGAGE_PRIVATE_PLACEMENT",SecurityType_MORTGAGE_PRIVATE_PLACEMENT_get, SecurityType_MORTGAGE_PRIVATE_PLACEMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_GENERAL_OBLIGATION_BONDS",SecurityType_GENERAL_OBLIGATION_BONDS_get, SecurityType_GENERAL_OBLIGATION_BONDS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_SHORTTERMLOANNOTE",SecurityType_SHORTTERMLOANNOTE_get, SecurityType_SHORTTERMLOANNOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_COMMERCIAL_PAPER",SecurityType_COMMERCIAL_PAPER_get, SecurityType_COMMERCIAL_PAPER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MORTGAGE_BACKED_SECURITIES",SecurityType_MORTGAGE_BACKED_SECURITIES_get, SecurityType_MORTGAGE_BACKED_SECURITIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_EURO_SOVEREIGNS",SecurityType_EURO_SOVEREIGNS_get, SecurityType_EURO_SOVEREIGNS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_TAX_REVENUE_ANTICIPATION_NOTE",SecurityType_TAX_REVENUE_ANTICIPATION_NOTE_get, SecurityType_TAX_REVENUE_ANTICIPATION_NOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_PFANDBRIEFE",SecurityType_PFANDBRIEFE_get, SecurityType_PFANDBRIEFE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_OTHER_ANTICIPATION_NOTES",SecurityType_OTHER_ANTICIPATION_NOTES_get, SecurityType_OTHER_ANTICIPATION_NOTES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_TAX_EXEMPT_COMMERCIAL_PAPER",SecurityType_TAX_EXEMPT_COMMERCIAL_PAPER_get, SecurityType_TAX_EXEMPT_COMMERCIAL_PAPER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_PRIVATEEXPORTFUNDING",SecurityType_PRIVATEEXPORTFUNDING_get, SecurityType_PRIVATEEXPORTFUNDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_OTHERANTICIPATIONNOTESBANGANETC",SecurityType_OTHERANTICIPATIONNOTESBANGANETC_get, SecurityType_OTHERANTICIPATIONNOTESBANGANETC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_TAX_ANTICIPATION_NOTE",SecurityType_TAX_ANTICIPATION_NOTE_get, SecurityType_TAX_ANTICIPATION_NOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_TREASURY_BILL",SecurityType_TREASURY_BILL_get, SecurityType_TREASURY_BILL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_PLAZOS_FIJOS",SecurityType_PLAZOS_FIJOS_get, SecurityType_PLAZOS_FIJOS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_EURO_COMMERCIAL_PAPER",SecurityType_EURO_COMMERCIAL_PAPER_get, SecurityType_EURO_COMMERCIAL_PAPER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MANDATORY_TENDER",SecurityType_MANDATORY_TENDER_get, SecurityType_MANDATORY_TENDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_COLLATERALIZED_MORTGAGE_OBLIGATION",SecurityType_COLLATERALIZED_MORTGAGE_OBLIGATION_get, SecurityType_COLLATERALIZED_MORTGAGE_OBLIGATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_PREFERREDSTOCK",SecurityType_PREFERREDSTOCK_get, SecurityType_PREFERREDSTOCK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_VARIABLERATEDEMANDNOTE",SecurityType_VARIABLERATEDEMANDNOTE_get, SecurityType_VARIABLERATEDEMANDNOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_DEFAULTED",SecurityType_DEFAULTED_get, SecurityType_DEFAULTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_INDEXED_LINKED",SecurityType_INDEXED_LINKED_get, SecurityType_INDEXED_LINKED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_IOETTE_MORTGAGE",SecurityType_IOETTE_MORTGAGE_get, SecurityType_IOETTE_MORTGAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CERTIFICATE_OF_DEPOSIT",SecurityType_CERTIFICATE_OF_DEPOSIT_get, SecurityType_CERTIFICATE_OF_DEPOSIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_BILLOFEXCHANGES",SecurityType_BILLOFEXCHANGES_get, SecurityType_BILLOFEXCHANGES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_PRINCIPALSTRIPOFACALLABLEBONDORNOTE",SecurityType_PRINCIPALSTRIPOFACALLABLEBONDORNOTE_get, SecurityType_PRINCIPALSTRIPOFACALLABLEBONDORNOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_EUROSOVEREIGNS",SecurityType_EUROSOVEREIGNS_get, SecurityType_EUROSOVEREIGNS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_TIME_DEPOSIT",SecurityType_TIME_DEPOSIT_get, SecurityType_TIME_DEPOSIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CORPORATEBOND",SecurityType_CORPORATEBOND_get, SecurityType_CORPORATEBOND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_FX_FORWARD",SecurityType_FX_FORWARD_get, SecurityType_FX_FORWARD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_US_CORPORATE_FLOATING_RATE_NOTES",SecurityType_US_CORPORATE_FLOATING_RATE_NOTES_get, SecurityType_US_CORPORATE_FLOATING_RATE_NOTES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_US_TREASURY_NOTE_TNOTE",SecurityType_US_TREASURY_NOTE_TNOTE_get, SecurityType_US_TREASURY_NOTE_TNOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MORTGAGEBACKEDSECURITIES",SecurityType_MORTGAGEBACKEDSECURITIES_get, SecurityType_MORTGAGEBACKEDSECURITIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_DEPOSIT_NOTES",SecurityType_DEPOSIT_NOTES_get, SecurityType_DEPOSIT_NOTES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CORPORATEPRIVATEPLACEMENT",SecurityType_CORPORATEPRIVATEPLACEMENT_get, SecurityType_CORPORATEPRIVATEPLACEMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_FEDERAL_HOUSING_AUTHORITY",SecurityType_FEDERAL_HOUSING_AUTHORITY_get, SecurityType_FEDERAL_HOUSING_AUTHORITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MATURED",SecurityType_MATURED_get, SecurityType_MATURED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_SWINGLINEFACILITY",SecurityType_SWINGLINEFACILITY_get, SecurityType_SWINGLINEFACILITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MULTI_LEG_INSTRUMENT",SecurityType_MULTI_LEG_INSTRUMENT_get, SecurityType_MULTI_LEG_INSTRUMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CANADIAN_PROVINCIAL_BONDS",SecurityType_CANADIAN_PROVINCIAL_BONDS_get, SecurityType_CANADIAN_PROVINCIAL_BONDS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MEDIUM_TERM_NOTES",SecurityType_MEDIUM_TERM_NOTES_get, SecurityType_MEDIUM_TERM_NOTES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_RETIRED",SecurityType_RETIRED_get, SecurityType_RETIRED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MUTUAL_FUND",SecurityType_MUTUAL_FUND_get, SecurityType_MUTUAL_FUND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_SECURITIESPLEDGE",SecurityType_SECURITIESPLEDGE_get, SecurityType_SECURITIESPLEDGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_COMMERCIALPAPER",SecurityType_COMMERCIALPAPER_get, SecurityType_COMMERCIALPAPER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_REPURCHASE_AGREEMENT",SecurityType_REPURCHASE_AGREEMENT_get, SecurityType_REPURCHASE_AGREEMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_BILL_OF_EXCHANGES",SecurityType_BILL_OF_EXCHANGES_get, SecurityType_BILL_OF_EXCHANGES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MUTUALFUND",SecurityType_MUTUALFUND_get, SecurityType_MUTUALFUND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_COLLATERALIZE_MORTGAGE_OBLIGATION",SecurityType_COLLATERALIZE_MORTGAGE_OBLIGATION_get, SecurityType_COLLATERALIZE_MORTGAGE_OBLIGATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_EXTENDEDCOMMNOTE",SecurityType_EXTENDEDCOMMNOTE_get, SecurityType_EXTENDEDCOMMNOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_FEDERAL_HOME_LOAN",SecurityType_FEDERAL_HOME_LOAN_get, SecurityType_FEDERAL_HOME_LOAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_REVOLVERLOAN",SecurityType_REVOLVERLOAN_get, SecurityType_REVOLVERLOAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_PRINCIPAL_STRIP_FROM_A_NON_CALLABLE_BOND_OR_NOTE",SecurityType_PRINCIPAL_STRIP_FROM_A_NON_CALLABLE_BOND_OR_NOTE_get, SecurityType_PRINCIPAL_STRIP_FROM_A_NON_CALLABLE_BOND_OR_NOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_STRUCTURED_NOTES",SecurityType_STRUCTURED_NOTES_get, SecurityType_STRUCTURED_NOTES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_INTERESTSTRIPFROMANYBONDORNOTE",SecurityType_INTERESTSTRIPFROMANYBONDORNOTE_get, SecurityType_INTERESTSTRIPFROMANYBONDORNOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CANADIAN_MORTGAGE_BONDS",SecurityType_CANADIAN_MORTGAGE_BONDS_get, SecurityType_CANADIAN_MORTGAGE_BONDS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_REPURCHASE",SecurityType_REPURCHASE_get, SecurityType_REPURCHASE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_AGENCY_POOLS",SecurityType_AGENCY_POOLS_get, SecurityType_AGENCY_POOLS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_EURO_CORPORATE_BOND",SecurityType_EURO_CORPORATE_BOND_get, SecurityType_EURO_CORPORATE_BOND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_SWING_LINE_FACILITY",SecurityType_SWING_LINE_FACILITY_get, SecurityType_SWING_LINE_FACILITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_USDSUPRANATIONALCOUPONS",SecurityType_USDSUPRANATIONALCOUPONS_get, SecurityType_USDSUPRANATIONALCOUPONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_REVOLVERTERMLOAN",SecurityType_REVOLVERTERMLOAN_get, SecurityType_REVOLVERTERMLOAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_LIQUIDITY_NOTE",SecurityType_LIQUIDITY_NOTE_get, SecurityType_LIQUIDITY_NOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MISCELLANEOUSPASSTHROUGH",SecurityType_MISCELLANEOUSPASSTHROUGH_get, SecurityType_MISCELLANEOUSPASSTHROUGH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CONVERTIBLE_BOND",SecurityType_CONVERTIBLE_BOND_get, SecurityType_CONVERTIBLE_BOND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_ASSET_BACKED_SECURITIES",SecurityType_ASSET_BACKED_SECURITIES_get, SecurityType_ASSET_BACKED_SECURITIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_WILDCARDENTRY",SecurityType_WILDCARDENTRY_get, SecurityType_WILDCARDENTRY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_YANKEECORPORATEBOND",SecurityType_YANKEECORPORATEBOND_get, SecurityType_YANKEECORPORATEBOND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_TAXREVENUEANTICIPATIONNOTE",SecurityType_TAXREVENUEANTICIPATIONNOTE_get, SecurityType_TAXREVENUEANTICIPATIONNOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_GOVERNMENT_NATIONAL_MORTGAGE_ASSOCIATION",SecurityType_GOVERNMENT_NATIONAL_MORTGAGE_ASSOCIATION_get, SecurityType_GOVERNMENT_NATIONAL_MORTGAGE_ASSOCIATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_BRADYBOND",SecurityType_BRADYBOND_get, SecurityType_BRADYBOND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_USTREASURYBILL",SecurityType_USTREASURYBILL_get, SecurityType_USTREASURYBILL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_STUDENT_LOAN_MARKETING_ASSOCIATION",SecurityType_STUDENT_LOAN_MARKETING_ASSOCIATION_get, SecurityType_STUDENT_LOAN_MARKETING_ASSOCIATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_EUROCORPORATEBOND",SecurityType_EUROCORPORATEBOND_get, SecurityType_EUROCORPORATEBOND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_FUTURE",SecurityType_FUTURE_get, SecurityType_FUTURE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_US_TREASURY_BILL_TBILL",SecurityType_US_TREASURY_BILL_TBILL_get, SecurityType_US_TREASURY_BILL_TBILL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_TREASURIES_PLUS_AGENCY_DEBENTURE",SecurityType_TREASURIES_PLUS_AGENCY_DEBENTURE_get, SecurityType_TREASURIES_PLUS_AGENCY_DEBENTURE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_EURO_CERTIFICATE_OF_DEPOSIT",SecurityType_EURO_CERTIFICATE_OF_DEPOSIT_get, SecurityType_EURO_CERTIFICATE_OF_DEPOSIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_BANKERS_ACCEPTANCE",SecurityType_BANKERS_ACCEPTANCE_get, SecurityType_BANKERS_ACCEPTANCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_AMENDEDRESTATED",SecurityType_AMENDEDRESTATED_get, SecurityType_AMENDEDRESTATED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_TERM_LOAN",SecurityType_TERM_LOAN_get, SecurityType_TERM_LOAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_BANKNOTES",SecurityType_BANKNOTES_get, SecurityType_BANKNOTES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_SHORT_TERM_LOAN_NOTE",SecurityType_SHORT_TERM_LOAN_NOTE_get, SecurityType_SHORT_TERM_LOAN_NOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_AMENDED_RESTATED",SecurityType_AMENDED_RESTATED_get, SecurityType_AMENDED_RESTATED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_INTEREST_RATE_SWAP",SecurityType_INTEREST_RATE_SWAP_get, SecurityType_INTEREST_RATE_SWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_EUROCOMMERCIALPAPER",SecurityType_EUROCOMMERCIALPAPER_get, SecurityType_EUROCOMMERCIALPAPER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_US_TREASURY_NOTE_UST",SecurityType_US_TREASURY_NOTE_UST_get, SecurityType_US_TREASURY_NOTE_UST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_US_TREASURY_BILL_USTB",SecurityType_US_TREASURY_BILL_USTB_get, SecurityType_US_TREASURY_BILL_USTB_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_FEDERAL_NATIONAL_MORTGAGE_ASSOCIATION",SecurityType_FEDERAL_NATIONAL_MORTGAGE_ASSOCIATION_get, SecurityType_FEDERAL_NATIONAL_MORTGAGE_ASSOCIATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_WITHDRAWN",SecurityType_WITHDRAWN_get, SecurityType_WITHDRAWN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CORPORATE_PRIVATE_PLACEMENT",SecurityType_CORPORATE_PRIVATE_PLACEMENT_get, SecurityType_CORPORATE_PRIVATE_PLACEMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CERTIFICATE_OF_OBLIGATION",SecurityType_CERTIFICATE_OF_OBLIGATION_get, SecurityType_CERTIFICATE_OF_OBLIGATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_INTEREST_STRIP_FROM_ANY_BOND_OR_NOTE",SecurityType_INTEREST_STRIP_FROM_ANY_BOND_OR_NOTE_get, SecurityType_INTEREST_STRIP_FROM_ANY_BOND_OR_NOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_STRUCTUREDNOTES",SecurityType_STRUCTUREDNOTES_get, SecurityType_STRUCTUREDNOTES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_BANKERSACCEPTANCE",SecurityType_BANKERSACCEPTANCE_get, SecurityType_BANKERSACCEPTANCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_NO_ISITC_SECURITY_TYPE",SecurityType_NO_ISITC_SECURITY_TYPE_get, SecurityType_NO_ISITC_SECURITY_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CALLLOANS",SecurityType_CALLLOANS_get, SecurityType_CALLLOANS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MISCELLANEOUS_PASS_THROUGH",SecurityType_MISCELLANEOUS_PASS_THROUGH_get, SecurityType_MISCELLANEOUS_PASS_THROUGH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_FEDERAL_AGENCY_COUPON",SecurityType_FEDERAL_AGENCY_COUPON_get, SecurityType_FEDERAL_AGENCY_COUPON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CORPORATE_BOND",SecurityType_CORPORATE_BOND_get, SecurityType_CORPORATE_BOND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_WILDCARD_ENTRY_FOR_USE_ON_SECURITY_DEFINITION_REQUEST",SecurityType_WILDCARD_ENTRY_FOR_USE_ON_SECURITY_DEFINITION_REQUEST_get, SecurityType_WILDCARD_ENTRY_FOR_USE_ON_SECURITY_DEFINITION_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CORPMORTGAGEBACKEDSECURITIES",SecurityType_CORPMORTGAGEBACKEDSECURITIES_get, SecurityType_CORPMORTGAGEBACKEDSECURITIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_EURO_SUPRANATIONAL_COUPONS",SecurityType_EURO_SUPRANATIONAL_COUPONS_get, SecurityType_EURO_SUPRANATIONAL_COUPONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CALL_LOANS",SecurityType_CALL_LOANS_get, SecurityType_CALL_LOANS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CERTIFICATEOFDEPOSIT",SecurityType_CERTIFICATEOFDEPOSIT_get, SecurityType_CERTIFICATEOFDEPOSIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_SECURED_LIQUIDITY_NOTE",SecurityType_SECURED_LIQUIDITY_NOTE_get, SecurityType_SECURED_LIQUIDITY_NOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_TIMEDEPOSIT",SecurityType_TIMEDEPOSIT_get, SecurityType_TIMEDEPOSIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_BANK_NOTES",SecurityType_BANK_NOTES_get, SecurityType_BANK_NOTES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_US_TREASURY_BILL",SecurityType_US_TREASURY_BILL_get, SecurityType_US_TREASURY_BILL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_GENERALOBLIGATIONBONDS",SecurityType_GENERALOBLIGATIONBONDS_get, SecurityType_GENERALOBLIGATIONBONDS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_COMMONSTOCK",SecurityType_COMMONSTOCK_get, SecurityType_COMMONSTOCK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_PLAZOSFIJOS",SecurityType_PLAZOSFIJOS_get, SecurityType_PLAZOSFIJOS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_SECURITIES_LOAN",SecurityType_SECURITIES_LOAN_get, SecurityType_SECURITIES_LOAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_SECURITIESLOAN",SecurityType_SECURITIESLOAN_get, SecurityType_SECURITIESLOAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MUNICIPAL_BOND",SecurityType_MUNICIPAL_BOND_get, SecurityType_MUNICIPAL_BOND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_REVENUE_BONDS",SecurityType_REVENUE_BONDS_get, SecurityType_REVENUE_BONDS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_SPECIALTAX",SecurityType_SPECIALTAX_get, SecurityType_SPECIALTAX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_PRINCIPALSTRIPFROMANONCALLABLEBONDORNOTE",SecurityType_PRINCIPALSTRIPFROMANONCALLABLEBONDORNOTE_get, SecurityType_PRINCIPALSTRIPFROMANONCALLABLEBONDORNOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_BRIDGE_LOAN",SecurityType_BRIDGE_LOAN_get, SecurityType_BRIDGE_LOAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_IOETTEMORTGAGE",SecurityType_IOETTEMORTGAGE_get, SecurityType_IOETTEMORTGAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_FEDERALAGENCYCOUPON",SecurityType_FEDERALAGENCYCOUPON_get, SecurityType_FEDERALAGENCYCOUPON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_COMMON_STOCK",SecurityType_COMMON_STOCK_get, SecurityType_COMMON_STOCK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_FEDERALAGENCYDISCOUNTNOTE",SecurityType_FEDERALAGENCYDISCOUNTNOTE_get, SecurityType_FEDERALAGENCYDISCOUNTNOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RoundingDirection_ROUNDUP",RoundingDirection_ROUNDUP_get, RoundingDirection_ROUNDUP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RoundingDirection_ROUND_DOWN",RoundingDirection_ROUND_DOWN_get, RoundingDirection_ROUND_DOWN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RoundingDirection_ROUND_TO_NEAREST",RoundingDirection_ROUND_TO_NEAREST_get, RoundingDirection_ROUND_TO_NEAREST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RoundingDirection_ROUND_UP",RoundingDirection_ROUND_UP_get, RoundingDirection_ROUND_UP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RoundingDirection_ROUNDDOWN",RoundingDirection_ROUNDDOWN_get, RoundingDirection_ROUNDDOWN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RoundingDirection_ROUNDNEAREST",RoundingDirection_ROUNDNEAREST_get, RoundingDirection_ROUNDNEAREST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeUnit_MINUTE",TimeUnit_MINUTE_get, TimeUnit_MINUTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeUnit_WEEK",TimeUnit_WEEK_get, TimeUnit_WEEK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeUnit_SECOND",TimeUnit_SECOND_get, TimeUnit_SECOND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeUnit_MONTH",TimeUnit_MONTH_get, TimeUnit_MONTH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeUnit_HOUR",TimeUnit_HOUR_get, TimeUnit_HOUR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeUnit_DAY",TimeUnit_DAY_get, TimeUnit_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeUnit_YEAR",TimeUnit_YEAR_get, TimeUnit_YEAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LegSwapType_MODIFIED_DURATION",LegSwapType_MODIFIED_DURATION_get, LegSwapType_MODIFIED_DURATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LegSwapType_PARFORPAR",LegSwapType_PARFORPAR_get, LegSwapType_PARFORPAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LegSwapType_RISK",LegSwapType_RISK_get, LegSwapType_RISK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LegSwapType_PAR_FOR_PAR",LegSwapType_PAR_FOR_PAR_get, LegSwapType_PAR_FOR_PAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LegSwapType_MODIFIEDDURATION",LegSwapType_MODIFIEDDURATION_get, LegSwapType_MODIFIEDDURATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LegSwapType_PROCEEDS",LegSwapType_PROCEEDS_get, LegSwapType_PROCEEDS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOITransType_REPLACE",IOITransType_REPLACE_get, IOITransType_REPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOITransType_NEW",IOITransType_NEW_get, IOITransType_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOITransType_CANCEL",IOITransType_CANCEL_get, IOITransType_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqResult_REQUESTFORPOSITIONNOTSUPPORTED",PosReqResult_REQUESTFORPOSITIONNOTSUPPORTED_get, PosReqResult_REQUESTFORPOSITIONNOTSUPPORTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqResult_VALID_REQUEST",PosReqResult_VALID_REQUEST_get, PosReqResult_VALID_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqResult_NO_POSITIONS_FOUND_THAT_MATCH_CRITERIA",PosReqResult_NO_POSITIONS_FOUND_THAT_MATCH_CRITERIA_get, PosReqResult_NO_POSITIONS_FOUND_THAT_MATCH_CRITERIA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqResult_NOT_AUTHORIZED_TO_REQUEST_POSITIONS",PosReqResult_NOT_AUTHORIZED_TO_REQUEST_POSITIONS_get, PosReqResult_NOT_AUTHORIZED_TO_REQUEST_POSITIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqResult_INVALID_OR_UNSUPPORTED_REQUEST",PosReqResult_INVALID_OR_UNSUPPORTED_REQUEST_get, PosReqResult_INVALID_OR_UNSUPPORTED_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqResult_NOTAUTHORIZEDTOREQUESTPOSITIONS",PosReqResult_NOTAUTHORIZEDTOREQUESTPOSITIONS_get, PosReqResult_NOTAUTHORIZEDTOREQUESTPOSITIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqResult_OTHER",PosReqResult_OTHER_get, PosReqResult_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqResult_NOPOSITIONSFOUNDTHATMATCHCRITERIA",PosReqResult_NOPOSITIONSFOUNDTHATMATCHCRITERIA_get, PosReqResult_NOPOSITIONSFOUNDTHATMATCHCRITERIA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqResult_REQUEST_FOR_POSITION_NOT_SUPPORTED",PosReqResult_REQUEST_FOR_POSITION_NOT_SUPPORTED_get, PosReqResult_REQUEST_FOR_POSITION_NOT_SUPPORTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqResult_INVALIDORUNSUPPORTEDREQUEST",PosReqResult_INVALIDORUNSUPPORTEDREQUEST_get, PosReqResult_INVALIDORUNSUPPORTEDREQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqResult_VALIDREQUEST",PosReqResult_VALIDREQUEST_get, PosReqResult_VALIDREQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstMode_ACCOUNTOVERRIDING",SettlInstMode_ACCOUNTOVERRIDING_get, SettlInstMode_ACCOUNTOVERRIDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstMode_REJECT",SettlInstMode_REJECT_get, SettlInstMode_REJECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstMode_DEFAULT",SettlInstMode_DEFAULT_get, SettlInstMode_DEFAULT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstMode_REQUEST_REJECT",SettlInstMode_REQUEST_REJECT_get, SettlInstMode_REQUEST_REJECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_OVERRIDING",SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_OVERRIDING_get, SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_OVERRIDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstMode_SIPROVIDED",SettlInstMode_SIPROVIDED_get, SettlInstMode_SIPROVIDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstMode_ACCOUNTSTANDING",SettlInstMode_ACCOUNTSTANDING_get, SettlInstMode_ACCOUNTSTANDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstMode_CIVORDERSINGLEACCT",SettlInstMode_CIVORDERSINGLEACCT_get, SettlInstMode_CIVORDERSINGLEACCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_STANDING",SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_STANDING_get, SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_STANDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstMode_SPECIFIC_ORDER_FOR_A_SINGLE_ACCOUNT",SettlInstMode_SPECIFIC_ORDER_FOR_A_SINGLE_ACCOUNT_get, SettlInstMode_SPECIFIC_ORDER_FOR_A_SINGLE_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstMode_STANDING_INSTRUCTIONS_PROVIDED",SettlInstMode_STANDING_INSTRUCTIONS_PROVIDED_get, SettlInstMode_STANDING_INSTRUCTIONS_PROVIDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PreviouslyReported_NO",PreviouslyReported_NO_get, PreviouslyReported_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PreviouslyReported_YES",PreviouslyReported_YES_get, PreviouslyReported_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_PEGGED",CustOrderHandlingInst_PEGGED_get, CustOrderHandlingInst_PEGGED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_MARKET_ON_OPEN",CustOrderHandlingInst_MARKET_ON_OPEN_get, CustOrderHandlingInst_MARKET_ON_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_SCALE",CustOrderHandlingInst_SCALE_get, CustOrderHandlingInst_SCALE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_FILL_OR_KILL",CustOrderHandlingInst_FILL_OR_KILL_get, CustOrderHandlingInst_FILL_OR_KILL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_ALL_OR_NONE",CustOrderHandlingInst_ALL_OR_NONE_get, CustOrderHandlingInst_ALL_OR_NONE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_NOT_HELD",CustOrderHandlingInst_NOT_HELD_get, CustOrderHandlingInst_NOT_HELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_DIRECTED_ORDER",CustOrderHandlingInst_DIRECTED_ORDER_get, CustOrderHandlingInst_DIRECTED_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_STOP_STOCK_TRANSACTION",CustOrderHandlingInst_STOP_STOCK_TRANSACTION_get, CustOrderHandlingInst_STOP_STOCK_TRANSACTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_OVER_THE_DAY",CustOrderHandlingInst_OVER_THE_DAY_get, CustOrderHandlingInst_OVER_THE_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_ADD_ON_ORDER",CustOrderHandlingInst_ADD_ON_ORDER_get, CustOrderHandlingInst_ADD_ON_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_MARKET_AT_CLOSE",CustOrderHandlingInst_MARKET_AT_CLOSE_get, CustOrderHandlingInst_MARKET_AT_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_LIMIT_ON_OPEN",CustOrderHandlingInst_LIMIT_ON_OPEN_get, CustOrderHandlingInst_LIMIT_ON_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_CASH_NOT_HELD",CustOrderHandlingInst_CASH_NOT_HELD_get, CustOrderHandlingInst_CASH_NOT_HELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_MARKET_ON_CLOSE",CustOrderHandlingInst_MARKET_ON_CLOSE_get, CustOrderHandlingInst_MARKET_ON_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_TIME_ORDER",CustOrderHandlingInst_TIME_ORDER_get, CustOrderHandlingInst_TIME_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_LIMIT_ON_CLOSE",CustOrderHandlingInst_LIMIT_ON_CLOSE_get, CustOrderHandlingInst_LIMIT_ON_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_IMMEDIATE_OR_CANCEL",CustOrderHandlingInst_IMMEDIATE_OR_CANCEL_get, CustOrderHandlingInst_IMMEDIATE_OR_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_TRAILING_STOP",CustOrderHandlingInst_TRAILING_STOP_get, CustOrderHandlingInst_TRAILING_STOP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_WORK",CustOrderHandlingInst_WORK_get, CustOrderHandlingInst_WORK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_RESERVE_SIZE_ORDER",CustOrderHandlingInst_RESERVE_SIZE_ORDER_get, CustOrderHandlingInst_RESERVE_SIZE_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_MINIMUM_QUANTITY",CustOrderHandlingInst_MINIMUM_QUANTITY_get, CustOrderHandlingInst_MINIMUM_QUANTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_MARKET_AT_OPEN",CustOrderHandlingInst_MARKET_AT_OPEN_get, CustOrderHandlingInst_MARKET_AT_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_IMBALANCE_ONLY",CustOrderHandlingInst_IMBALANCE_ONLY_get, CustOrderHandlingInst_IMBALANCE_ONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION",CustOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION_get, CustOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityStatus_INACTIVE",SecurityStatus_INACTIVE_get, SecurityStatus_INACTIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityStatus_ACTIVE",SecurityStatus_ACTIVE_get, SecurityStatus_ACTIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ProcessCode_SOFT_DOLLAR",ProcessCode_SOFT_DOLLAR_get, ProcessCode_SOFT_DOLLAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ProcessCode_STEPOUTSOFT",ProcessCode_STEPOUTSOFT_get, ProcessCode_STEPOUTSOFT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ProcessCode_STEPOUT",ProcessCode_STEPOUT_get, ProcessCode_STEPOUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ProcessCode_PLAN_SPONSOR",ProcessCode_PLAN_SPONSOR_get, ProcessCode_PLAN_SPONSOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ProcessCode_STEP_IN",ProcessCode_STEP_IN_get, ProcessCode_STEP_IN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ProcessCode_STEPIN",ProcessCode_STEPIN_get, ProcessCode_STEPIN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ProcessCode_REGULAR",ProcessCode_REGULAR_get, ProcessCode_REGULAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ProcessCode_SOFTDOLLAR",ProcessCode_SOFTDOLLAR_get, ProcessCode_SOFTDOLLAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ProcessCode_PLANSPONSOR",ProcessCode_PLANSPONSOR_get, ProcessCode_PLANSPONSOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ProcessCode_STEPINSOFT",ProcessCode_STEPINSOFT_get, ProcessCode_STEPINSOFT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ProcessCode_SOFT_DOLLAR_STEP_OUT",ProcessCode_SOFT_DOLLAR_STEP_OUT_get, ProcessCode_SOFT_DOLLAR_STEP_OUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ProcessCode_STEP_OUT",ProcessCode_STEP_OUT_get, ProcessCode_STEP_OUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ProcessCode_SOFT_DOLLAR_STEP_IN",ProcessCode_SOFT_DOLLAR_STEP_IN_get, ProcessCode_SOFT_DOLLAR_STEP_IN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_TRY_TO_STOP",ExecInst_TRY_TO_STOP_get, ExecInst_TRY_TO_STOP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_PEG_TO_LIMIT_PRICE",ExecInst_PEG_TO_LIMIT_PRICE_get, ExecInst_PEG_TO_LIMIT_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_EXECUTE_AS_DURATION_NEUTRAL",ExecInst_EXECUTE_AS_DURATION_NEUTRAL_get, ExecInst_EXECUTE_AS_DURATION_NEUTRAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_PARTICIPANT_DONT_INITIATE",ExecInst_PARTICIPANT_DONT_INITIATE_get, ExecInst_PARTICIPANT_DONT_INITIATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_REINSTATE_ON_TRADING_HALT",ExecInst_REINSTATE_ON_TRADING_HALT_get, ExecInst_REINSTATE_ON_TRADING_HALT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_NO_CROSS",ExecInst_NO_CROSS_get, ExecInst_NO_CROSS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_PEGVWAP",ExecInst_PEGVWAP_get, ExecInst_PEGVWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_STRICT_SCALE",ExecInst_STRICT_SCALE_get, ExecInst_STRICT_SCALE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_AON",ExecInst_AON_get, ExecInst_AON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_TRAILING_STOP_PEG",ExecInst_TRAILING_STOP_PEG_get, ExecInst_TRAILING_STOP_PEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_TRAILSTOPPEG",ExecInst_TRAILSTOPPEG_get, ExecInst_TRAILSTOPPEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_MARKPEG",ExecInst_MARKPEG_get, ExecInst_MARKPEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_MIDPRCPEG",ExecInst_MIDPRCPEG_get, ExecInst_MIDPRCPEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_OKCROSS",ExecInst_OKCROSS_get, ExecInst_OKCROSS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_EXECUTE_AS_FX_NEUTRAL",ExecInst_EXECUTE_AS_FX_NEUTRAL_get, ExecInst_EXECUTE_AS_FX_NEUTRAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_CUSTDISPINST",ExecInst_CUSTDISPINST_get, ExecInst_CUSTDISPINST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_IGNOREPRICECHK",ExecInst_IGNOREPRICECHK_get, ExecInst_IGNOREPRICECHK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_STRICTLIMIT",ExecInst_STRICTLIMIT_get, ExecInst_STRICTLIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_WORKTOSTRATEGY",ExecInst_WORKTOSTRATEGY_get, ExecInst_WORKTOSTRATEGY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_OK_TO_CROSS",ExecInst_OK_TO_CROSS_get, ExecInst_OK_TO_CROSS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_SUSPEND_ON_SYSTEM_FAILURE",ExecInst_SUSPEND_ON_SYSTEM_FAILURE_get, ExecInst_SUSPEND_ON_SYSTEM_FAILURE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_REINSTATE_ON_SYSTEM_FAILURE",ExecInst_REINSTATE_ON_SYSTEM_FAILURE_get, ExecInst_REINSTATE_ON_SYSTEM_FAILURE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_GO_ALONG",ExecInst_GO_ALONG_get, ExecInst_GO_ALONG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_INSTITONLY",ExecInst_INSTITONLY_get, ExecInst_INSTITONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_DO_NOT_INCREASE",ExecInst_DO_NOT_INCREASE_get, ExecInst_DO_NOT_INCREASE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_SUSPEND",ExecInst_SUSPEND_get, ExecInst_SUSPEND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_TRYTOSTOP",ExecInst_TRYTOSTOP_get, ExecInst_TRYTOSTOP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER",ExecInst_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER_get, ExecInst_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_SUSPEND_ON_TRADING_HALT",ExecInst_SUSPEND_ON_TRADING_HALT_get, ExecInst_SUSPEND_ON_TRADING_HALT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_INTERMARKET_SWEEP",ExecInst_INTERMARKET_SWEEP_get, ExecInst_INTERMARKET_SWEEP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_IGNORE_PRICE_VALIDITY_CHECKS",ExecInst_IGNORE_PRICE_VALIDITY_CHECKS_get, ExecInst_IGNORE_PRICE_VALIDITY_CHECKS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_PARTICIPATE_DONT_INITIATE",ExecInst_PARTICIPATE_DONT_INITIATE_get, ExecInst_PARTICIPATE_DONT_INITIATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_LASTPEG",ExecInst_LASTPEG_get, ExecInst_LASTPEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_PEG_TO_VWAP",ExecInst_PEG_TO_VWAP_get, ExecInst_PEG_TO_VWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_PRIMARY_PEG",ExecInst_PRIMARY_PEG_get, ExecInst_PRIMARY_PEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_NONNEGO",ExecInst_NONNEGO_get, ExecInst_NONNEGO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_BEST_EXECUTION",ExecInst_BEST_EXECUTION_get, ExecInst_BEST_EXECUTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_STAY_ON_BID_SIDE",ExecInst_STAY_ON_BID_SIDE_get, ExecInst_STAY_ON_BID_SIDE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_NOTHELD",ExecInst_NOTHELD_get, ExecInst_NOTHELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_STRICTSCALE",ExecInst_STRICTSCALE_get, ExecInst_STRICTSCALE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_REINSTATE_ON_CONNECTION_LOSS",ExecInst_REINSTATE_ON_CONNECTION_LOSS_get, ExecInst_REINSTATE_ON_CONNECTION_LOSS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_DNI",ExecInst_DNI_get, ExecInst_DNI_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_TRYTOSCALE",ExecInst_TRYTOSCALE_get, ExecInst_TRYTOSCALE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_PERCENT_OF_VOLUME",ExecInst_PERCENT_OF_VOLUME_get, ExecInst_PERCENT_OF_VOLUME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_GOALONG",ExecInst_GOALONG_get, ExecInst_GOALONG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_WORK",ExecInst_WORK_get, ExecInst_WORK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_HELD",ExecInst_HELD_get, ExecInst_HELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_NOCROSS",ExecInst_NOCROSS_get, ExecInst_NOCROSS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_RELEASE_FROM_SUSPENSION",ExecInst_RELEASE_FROM_SUSPENSION_get, ExecInst_RELEASE_FROM_SUSPENSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_STRICT_LIMIT",ExecInst_STRICT_LIMIT_get, ExecInst_STRICT_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_OPENPEG",ExecInst_OPENPEG_get, ExecInst_OPENPEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_STAY_ON_BIDSIDE",ExecInst_STAY_ON_BIDSIDE_get, ExecInst_STAY_ON_BIDSIDE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_STAY_ON_OFFERSIDE",ExecInst_STAY_ON_OFFERSIDE_get, ExecInst_STAY_ON_OFFERSIDE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_OVER_THE_DAY",ExecInst_OVER_THE_DAY_get, ExecInst_OVER_THE_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_RESTATEONTRADINGHALT",ExecInst_RESTATEONTRADINGHALT_get, ExecInst_RESTATEONTRADINGHALT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_INSTITUTIONS_ONLY",ExecInst_INSTITUTIONS_ONLY_get, ExecInst_INSTITUTIONS_ONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_NOT_HELD",ExecInst_NOT_HELD_get, ExecInst_NOT_HELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_CANCELONTRADINGHALT",ExecInst_CANCELONTRADINGHALT_get, ExecInst_CANCELONTRADINGHALT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_CANCELONSYSFAIL",ExecInst_CANCELONSYSFAIL_get, ExecInst_CANCELONSYSFAIL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_CANCEL_ON_SYSTEM_FAILURE",ExecInst_CANCEL_ON_SYSTEM_FAILURE_get, ExecInst_CANCEL_ON_SYSTEM_FAILURE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_MARKET_PEG",ExecInst_MARKET_PEG_get, ExecInst_MARKET_PEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_TRADEALONG",ExecInst_TRADEALONG_get, ExecInst_TRADEALONG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_CALL_FIRST",ExecInst_CALL_FIRST_get, ExecInst_CALL_FIRST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_PEGTOLIMIT",ExecInst_PEGTOLIMIT_get, ExecInst_PEGTOLIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_EXECUTE_AS_DELTA_NEUTRAL_USING_VOLATILITY_PROVIDED",ExecInst_EXECUTE_AS_DELTA_NEUTRAL_USING_VOLATILITY_PROVIDED_get, ExecInst_EXECUTE_AS_DELTA_NEUTRAL_USING_VOLATILITY_PROVIDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_SINGLE_EXECUTION_REQUESTED_FOR_BLOCK_TRADE",ExecInst_SINGLE_EXECUTION_REQUESTED_FOR_BLOCK_TRADE_get, ExecInst_SINGLE_EXECUTION_REQUESTED_FOR_BLOCK_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_NON_NEGOTIABLE",ExecInst_NON_NEGOTIABLE_get, ExecInst_NON_NEGOTIABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_TRY_TO_SCALE",ExecInst_TRY_TO_SCALE_get, ExecInst_TRY_TO_SCALE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_EXTERNAL_ROUTING_ALLOWED",ExecInst_EXTERNAL_ROUTING_ALLOWED_get, ExecInst_EXTERNAL_ROUTING_ALLOWED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_WORK_TO_TARGET_STRATEGY",ExecInst_WORK_TO_TARGET_STRATEGY_get, ExecInst_WORK_TO_TARGET_STRATEGY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_STAY_ON_OFFER_SIDE",ExecInst_STAY_ON_OFFER_SIDE_get, ExecInst_STAY_ON_OFFER_SIDE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_CUSTOMER_DISPLAY_INSTRUCTION",ExecInst_CUSTOMER_DISPLAY_INSTRUCTION_get, ExecInst_CUSTOMER_DISPLAY_INSTRUCTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_OVERDAY",ExecInst_OVERDAY_get, ExecInst_OVERDAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_LAST_PEG",ExecInst_LAST_PEG_get, ExecInst_LAST_PEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_CALLFIRST",ExecInst_CALLFIRST_get, ExecInst_CALLFIRST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_REINSTATE_ON_SYSTEM_FAILUE",ExecInst_REINSTATE_ON_SYSTEM_FAILUE_get, ExecInst_REINSTATE_ON_SYSTEM_FAILUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_DO_NOT_REDUCE",ExecInst_DO_NOT_REDUCE_get, ExecInst_DO_NOT_REDUCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_MID_PRICE_PEG",ExecInst_MID_PRICE_PEG_get, ExecInst_MID_PRICE_PEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_ALL_OR_NONE",ExecInst_ALL_OR_NONE_get, ExecInst_ALL_OR_NONE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_OPENING_PEG",ExecInst_OPENING_PEG_get, ExecInst_OPENING_PEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_PERCVOL",ExecInst_PERCVOL_get, ExecInst_PERCVOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_SUSPEND_ON_CONNECTION_LOSS",ExecInst_SUSPEND_ON_CONNECTION_LOSS_get, ExecInst_SUSPEND_ON_CONNECTION_LOSS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_CANCEL_ON_CONNECTION_LOSS",ExecInst_CANCEL_ON_CONNECTION_LOSS_get, ExecInst_CANCEL_ON_CONNECTION_LOSS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_EXTERNAL_ROUTING_NOT_ALLOWED",ExecInst_EXTERNAL_ROUTING_NOT_ALLOWED_get, ExecInst_EXTERNAL_ROUTING_NOT_ALLOWED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_CANCEL_IF_NOT_BEST",ExecInst_CANCEL_IF_NOT_BEST_get, ExecInst_CANCEL_IF_NOT_BEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_PARTNOTINIT",ExecInst_PARTNOTINIT_get, ExecInst_PARTNOTINIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_CXLIFNOTBEST",ExecInst_CXLIFNOTBEST_get, ExecInst_CXLIFNOTBEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_NETTING",ExecInst_NETTING_get, ExecInst_NETTING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_IMBALANCE_ONLY",ExecInst_IMBALANCE_ONLY_get, ExecInst_IMBALANCE_ONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_CANCEL_ON_TRADING_HALT",ExecInst_CANCEL_ON_TRADING_HALT_get, ExecInst_CANCEL_ON_TRADING_HALT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_TRADE_ALONG",ExecInst_TRADE_ALONG_get, ExecInst_TRADE_ALONG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_DNR",ExecInst_DNR_get, ExecInst_DNR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_STAYOFFER",ExecInst_STAYOFFER_get, ExecInst_STAYOFFER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_STAYBID",ExecInst_STAYBID_get, ExecInst_STAYBID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_RESTATEONSYSFAIL",ExecInst_RESTATEONSYSFAIL_get, ExecInst_RESTATEONSYSFAIL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_PRIMPEG",ExecInst_PRIMPEG_get, ExecInst_PRIMPEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_REPLACE",ExecType_REPLACE_get, ExecType_REPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_NEW",ExecType_NEW_get, ExecType_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_CALCULATED",ExecType_CALCULATED_get, ExecType_CALCULATED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_PENDINGNEW",ExecType_PENDINGNEW_get, ExecType_PENDINGNEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_ORDERSTATUS",ExecType_ORDERSTATUS_get, ExecType_ORDERSTATUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_PENDING_CANCEL",ExecType_PENDING_CANCEL_get, ExecType_PENDING_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_TRADE_IN_A_CLEARING_HOLD",ExecType_TRADE_IN_A_CLEARING_HOLD_get, ExecType_TRADE_IN_A_CLEARING_HOLD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_TRADE_HAS_BEEN_RELEASED_TO_CLEARING",ExecType_TRADE_HAS_BEEN_RELEASED_TO_CLEARING_get, ExecType_TRADE_HAS_BEEN_RELEASED_TO_CLEARING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_ORDER_STATUS",ExecType_ORDER_STATUS_get, ExecType_ORDER_STATUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_PENDING_CANCEL_REPLACE",ExecType_PENDING_CANCEL_REPLACE_get, ExecType_PENDING_CANCEL_REPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_PARTIAL_FILL",ExecType_PARTIAL_FILL_get, ExecType_PARTIAL_FILL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_PENDINGCXL",ExecType_PENDINGCXL_get, ExecType_PENDINGCXL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_PENDING_NEW",ExecType_PENDING_NEW_get, ExecType_PENDING_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_STOPPED",ExecType_STOPPED_get, ExecType_STOPPED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_CANCELED",ExecType_CANCELED_get, ExecType_CANCELED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_PENDING_REPLACE",ExecType_PENDING_REPLACE_get, ExecType_PENDING_REPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_TRADE",ExecType_TRADE_get, ExecType_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_TRADE_CORRECT",ExecType_TRADE_CORRECT_get, ExecType_TRADE_CORRECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_PENDINGREPLACE",ExecType_PENDINGREPLACE_get, ExecType_PENDINGREPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_SUSPENDED",ExecType_SUSPENDED_get, ExecType_SUSPENDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_FILL",ExecType_FILL_get, ExecType_FILL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_DONE",ExecType_DONE_get, ExecType_DONE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_RESTATED",ExecType_RESTATED_get, ExecType_RESTATED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_REJECTED",ExecType_REJECTED_get, ExecType_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_REPLACED",ExecType_REPLACED_get, ExecType_REPLACED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_EXPIRED",ExecType_EXPIRED_get, ExecType_EXPIRED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_DONE_FOR_DAY",ExecType_DONE_FOR_DAY_get, ExecType_DONE_FOR_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_TRIGGERED_OR_ACTIVATED_BY_SYSTEM",ExecType_TRIGGERED_OR_ACTIVATED_BY_SYSTEM_get, ExecType_TRIGGERED_OR_ACTIVATED_BY_SYSTEM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_TRADECORRECT",ExecType_TRADECORRECT_get, ExecType_TRADECORRECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_TRADECANCEL",ExecType_TRADECANCEL_get, ExecType_TRADECANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_TRADE_CANCEL",ExecType_TRADE_CANCEL_get, ExecType_TRADE_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_CANCELLED",ExecType_CANCELLED_get, ExecType_CANCELLED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultilegModel_USER_DEFINED_MULTLEG_SECURITY",MultilegModel_USER_DEFINED_MULTLEG_SECURITY_get, MultilegModel_USER_DEFINED_MULTLEG_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultilegModel_PREDEFINED_MULTILEG_SECURITY",MultilegModel_PREDEFINED_MULTILEG_SECURITY_get, MultilegModel_PREDEFINED_MULTILEG_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultilegModel_USER_DEFINED_NON_SECURITIZED_MULTILEG",MultilegModel_USER_DEFINED_NON_SECURITIZED_MULTILEG_get, MultilegModel_USER_DEFINED_NON_SECURITIZED_MULTILEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_SWAP_NEXT_START_DATE",EventType_SWAP_NEXT_START_DATE_get, EventType_SWAP_NEXT_START_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_LAST_ELIGIBLE_TRADE_DATE",EventType_LAST_ELIGIBLE_TRADE_DATE_get, EventType_LAST_ELIGIBLE_TRADE_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_FIRST_DELIVERY_DATE",EventType_FIRST_DELIVERY_DATE_get, EventType_FIRST_DELIVERY_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_TENDER",EventType_TENDER_get, EventType_TENDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_INITIAL_INVENTORY_DUE_DATE",EventType_INITIAL_INVENTORY_DUE_DATE_get, EventType_INITIAL_INVENTORY_DUE_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_FIRST_INTENT_DATE",EventType_FIRST_INTENT_DATE_get, EventType_FIRST_INTENT_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_ACTIVATION",EventType_ACTIVATION_get, EventType_ACTIVATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_PUT",EventType_PUT_get, EventType_PUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_SWAP_START_DATE",EventType_SWAP_START_DATE_get, EventType_SWAP_START_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_SWAP_NEXT_ROLL_DATE",EventType_SWAP_NEXT_ROLL_DATE_get, EventType_SWAP_NEXT_ROLL_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_LAST_DELIVERY_DATE",EventType_LAST_DELIVERY_DATE_get, EventType_LAST_DELIVERY_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_POSITION_REMOVAL_DATE",EventType_POSITION_REMOVAL_DATE_get, EventType_POSITION_REMOVAL_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_SWAP_ROLL_DATE",EventType_SWAP_ROLL_DATE_get, EventType_SWAP_ROLL_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_FINAL_INVENTORY_DUE_DATE",EventType_FINAL_INVENTORY_DUE_DATE_get, EventType_FINAL_INVENTORY_DUE_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_OTHER",EventType_OTHER_get, EventType_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_INACTIVIATION",EventType_INACTIVIATION_get, EventType_INACTIVIATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_SINKINGFUNDCALL",EventType_SINKINGFUNDCALL_get, EventType_SINKINGFUNDCALL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_SWAP_END_DATE",EventType_SWAP_END_DATE_get, EventType_SWAP_END_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_LAST_INTENT_DATE",EventType_LAST_INTENT_DATE_get, EventType_LAST_INTENT_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_SINKING_FUND_CALL",EventType_SINKING_FUND_CALL_get, EventType_SINKING_FUND_CALL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_CALL",EventType_CALL_get, EventType_CALL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeAllocIndicator_ALLOCATIONREQUIREDALLOCATIONINFORMATIONNOTPROVIDED",TradeAllocIndicator_ALLOCATIONREQUIREDALLOCATIONINFORMATIONNOTPROVIDED_get, TradeAllocIndicator_ALLOCATIONREQUIREDALLOCATIONINFORMATIONNOTPROVIDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeAllocIndicator_ALLOCATION_REQUIRED",TradeAllocIndicator_ALLOCATION_REQUIRED_get, TradeAllocIndicator_ALLOCATION_REQUIRED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeAllocIndicator_ALLOCATION_TO_CLAIM_ACCOUNT",TradeAllocIndicator_ALLOCATION_TO_CLAIM_ACCOUNT_get, TradeAllocIndicator_ALLOCATION_TO_CLAIM_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeAllocIndicator_USEALLOCATIONPROVIDEDWITHTHETRADE",TradeAllocIndicator_USEALLOCATIONPROVIDEDWITHTHETRADE_get, TradeAllocIndicator_USEALLOCATIONPROVIDEDWITHTHETRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeAllocIndicator_ALLOCATION_FROM_EXECUTOR",TradeAllocIndicator_ALLOCATION_FROM_EXECUTOR_get, TradeAllocIndicator_ALLOCATION_FROM_EXECUTOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeAllocIndicator_USE_ALLOCATION_PROVIDED_WITH_THE_TRADE",TradeAllocIndicator_USE_ALLOCATION_PROVIDED_WITH_THE_TRADE_get, TradeAllocIndicator_USE_ALLOCATION_PROVIDED_WITH_THE_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeAllocIndicator_ALLOCATIONNOTREQUIRED",TradeAllocIndicator_ALLOCATIONNOTREQUIRED_get, TradeAllocIndicator_ALLOCATIONNOTREQUIRED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeAllocIndicator_ALLOCATION_NOT_REQUIRED",TradeAllocIndicator_ALLOCATION_NOT_REQUIRED_get, TradeAllocIndicator_ALLOCATION_NOT_REQUIRED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeAllocIndicator_ALLOCATION_GIVE_UP_EXECUTOR",TradeAllocIndicator_ALLOCATION_GIVE_UP_EXECUTOR_get, TradeAllocIndicator_ALLOCATION_GIVE_UP_EXECUTOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserStatus_NOT_LOGGED_IN",UserStatus_NOT_LOGGED_IN_get, UserStatus_NOT_LOGGED_IN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserStatus_PASSWORD_INCORRECT",UserStatus_PASSWORD_INCORRECT_get, UserStatus_PASSWORD_INCORRECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserStatus_USERNOTRECOGNISED",UserStatus_USERNOTRECOGNISED_get, UserStatus_USERNOTRECOGNISED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserStatus_LOGGED_IN",UserStatus_LOGGED_IN_get, UserStatus_LOGGED_IN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserStatus_PASSWORDCHANGED",UserStatus_PASSWORDCHANGED_get, UserStatus_PASSWORDCHANGED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserStatus_FORCED_USER_LOGOUT_BY_EXCHANGE",UserStatus_FORCED_USER_LOGOUT_BY_EXCHANGE_get, UserStatus_FORCED_USER_LOGOUT_BY_EXCHANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserStatus_USER_NOT_RECOGNISED",UserStatus_USER_NOT_RECOGNISED_get, UserStatus_USER_NOT_RECOGNISED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserStatus_NOTLOGGEDIN",UserStatus_NOTLOGGEDIN_get, UserStatus_NOTLOGGEDIN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserStatus_PASSWORD_CHANGED",UserStatus_PASSWORD_CHANGED_get, UserStatus_PASSWORD_CHANGED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserStatus_OTHER",UserStatus_OTHER_get, UserStatus_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserStatus_LOGGEDIN",UserStatus_LOGGEDIN_get, UserStatus_LOGGEDIN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserStatus_SESSION_SHUTDOWN_WARNING",UserStatus_SESSION_SHUTDOWN_WARNING_get, UserStatus_SESSION_SHUTDOWN_WARNING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserStatus_PASSWORDINCORRECT",UserStatus_PASSWORDINCORRECT_get, UserStatus_PASSWORDINCORRECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrRegistry_PHYSICAL",InstrRegistry_PHYSICAL_get, InstrRegistry_PHYSICAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrRegistry_COUNTRY",InstrRegistry_COUNTRY_get, InstrRegistry_COUNTRY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrRegistry_CUSTODIAN",InstrRegistry_CUSTODIAN_get, InstrRegistry_CUSTODIAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderDelayUnit_WEEKS",OrderDelayUnit_WEEKS_get, OrderDelayUnit_WEEKS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderDelayUnit_TENTHS_OF_A_SECOND",OrderDelayUnit_TENTHS_OF_A_SECOND_get, OrderDelayUnit_TENTHS_OF_A_SECOND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderDelayUnit_SECONDS",OrderDelayUnit_SECONDS_get, OrderDelayUnit_SECONDS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderDelayUnit_MONTHS",OrderDelayUnit_MONTHS_get, OrderDelayUnit_MONTHS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderDelayUnit_YEARS",OrderDelayUnit_YEARS_get, OrderDelayUnit_YEARS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderDelayUnit_NANOSECONDS",OrderDelayUnit_NANOSECONDS_get, OrderDelayUnit_NANOSECONDS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderDelayUnit_HUNDREDTHS_OF_A_SECOND",OrderDelayUnit_HUNDREDTHS_OF_A_SECOND_get, OrderDelayUnit_HUNDREDTHS_OF_A_SECOND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderDelayUnit_HOURS",OrderDelayUnit_HOURS_get, OrderDelayUnit_HOURS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderDelayUnit_MICROSECONDS",OrderDelayUnit_MICROSECONDS_get, OrderDelayUnit_MICROSECONDS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderDelayUnit_MINUTES",OrderDelayUnit_MINUTES_get, OrderDelayUnit_MINUTES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderDelayUnit_MILLISECONDS",OrderDelayUnit_MILLISECONDS_get, OrderDelayUnit_MILLISECONDS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderDelayUnit_DAYS",OrderDelayUnit_DAYS_get, OrderDelayUnit_DAYS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradedFlatSwitch_NO",TradedFlatSwitch_NO_get, TradedFlatSwitch_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradedFlatSwitch_YES",TradedFlatSwitch_YES_get, TradedFlatSwitch_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdRptStatus_ACCEPTED_WITH_ERRORS",TrdRptStatus_ACCEPTED_WITH_ERRORS_get, TrdRptStatus_ACCEPTED_WITH_ERRORS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdRptStatus_REJECTED",TrdRptStatus_REJECTED_get, TrdRptStatus_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdRptStatus_ACCEPTED",TrdRptStatus_ACCEPTED_get, TrdRptStatus_ACCEPTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_CANCELEDDUETOLOCKMARKET",QuoteStatus_CANCELEDDUETOLOCKMARKET_get, QuoteStatus_CANCELEDDUETOLOCKMARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_REJ",QuoteStatus_REJ_get, QuoteStatus_REJ_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_PENDING",QuoteStatus_PENDING_get, QuoteStatus_PENDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_LOCKEDMARKETWARNING",QuoteStatus_LOCKEDMARKETWARNING_get, QuoteStatus_LOCKEDMARKETWARNING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_CROSSMARKETWARNING",QuoteStatus_CROSSMARKETWARNING_get, QuoteStatus_CROSSMARKETWARNING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_REMOVED",QuoteStatus_REMOVED_get, QuoteStatus_REMOVED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_CXLUNDER",QuoteStatus_CXLUNDER_get, QuoteStatus_CXLUNDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_PENDING_END_TRADE",QuoteStatus_PENDING_END_TRADE_get, QuoteStatus_PENDING_END_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_CROSS_MARKET_WARNING",QuoteStatus_CROSS_MARKET_WARNING_get, QuoteStatus_CROSS_MARKET_WARNING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_QUOTENOTFOUND",QuoteStatus_QUOTENOTFOUND_get, QuoteStatus_QUOTENOTFOUND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_CANCELED",QuoteStatus_CANCELED_get, QuoteStatus_CANCELED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_LOCKED_MARKET_WARNING",QuoteStatus_LOCKED_MARKET_WARNING_get, QuoteStatus_LOCKED_MARKET_WARNING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_CXLSYM",QuoteStatus_CXLSYM_get, QuoteStatus_CXLSYM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_CANCELED_FOR_UNDERLYING",QuoteStatus_CANCELED_FOR_UNDERLYING_get, QuoteStatus_CANCELED_FOR_UNDERLYING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_UNSOLICITED_QUOTE_REPLENISHMENT",QuoteStatus_UNSOLICITED_QUOTE_REPLENISHMENT_get, QuoteStatus_UNSOLICITED_QUOTE_REPLENISHMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_TOO_LATE_TO_END",QuoteStatus_TOO_LATE_TO_END_get, QuoteStatus_TOO_LATE_TO_END_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_CANCELED_DUE_TO_LOCK_MARKET",QuoteStatus_CANCELED_DUE_TO_LOCK_MARKET_get, QuoteStatus_CANCELED_DUE_TO_LOCK_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_CANCELED_DUE_TO_CROSS_MARKET",QuoteStatus_CANCELED_DUE_TO_CROSS_MARKET_get, QuoteStatus_CANCELED_DUE_TO_CROSS_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_ACCPT",QuoteStatus_ACCPT_get, QuoteStatus_ACCPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_CANCELED_FOR_SECURITY_TYPE",QuoteStatus_CANCELED_FOR_SECURITY_TYPE_get, QuoteStatus_CANCELED_FOR_SECURITY_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_CANCELED_ALL",QuoteStatus_CANCELED_ALL_get, QuoteStatus_CANCELED_ALL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_PASS",QuoteStatus_PASS_get, QuoteStatus_PASS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_CANCELEDDUETOCROSSMARKET",QuoteStatus_CANCELEDDUETOCROSSMARKET_get, QuoteStatus_CANCELEDDUETOCROSSMARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_REJECTED",QuoteStatus_REJECTED_get, QuoteStatus_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_QUERY",QuoteStatus_QUERY_get, QuoteStatus_QUERY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_CXLSECTYPE",QuoteStatus_CXLSECTYPE_get, QuoteStatus_CXLSECTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_ACCEPTED",QuoteStatus_ACCEPTED_get, QuoteStatus_ACCEPTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_EXPIRED",QuoteStatus_EXPIRED_get, QuoteStatus_EXPIRED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_CANCELED_FOR_SYMBOL",QuoteStatus_CANCELED_FOR_SYMBOL_get, QuoteStatus_CANCELED_FOR_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_REMOVED_FROM_MARKET",QuoteStatus_REMOVED_FROM_MARKET_get, QuoteStatus_REMOVED_FROM_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_ACTIVE",QuoteStatus_ACTIVE_get, QuoteStatus_ACTIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_CANCEL_FOR_SYMBOL",QuoteStatus_CANCEL_FOR_SYMBOL_get, QuoteStatus_CANCEL_FOR_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_CXLALL",QuoteStatus_CXLALL_get, QuoteStatus_CXLALL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_QUOTE_NOT_FOUND",QuoteStatus_QUOTE_NOT_FOUND_get, QuoteStatus_QUOTE_NOT_FOUND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SolicitedFlag_NO",SolicitedFlag_NO_get, SolicitedFlag_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SolicitedFlag_YES",SolicitedFlag_YES_get, SolicitedFlag_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RiskLimitType_GROSS_LIMIT",RiskLimitType_GROSS_LIMIT_get, RiskLimitType_GROSS_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RiskLimitType_SHORT_LIMIT",RiskLimitType_SHORT_LIMIT_get, RiskLimitType_SHORT_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RiskLimitType_LONG_LIMIT",RiskLimitType_LONG_LIMIT_get, RiskLimitType_LONG_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RiskLimitType_NET_LIMIT",RiskLimitType_NET_LIMIT_get, RiskLimitType_NET_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RiskLimitType_EXPOSURE",RiskLimitType_EXPOSURE_get, RiskLimitType_EXPOSURE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ShortSaleReason_DEALER_SOLD_SHORT",ShortSaleReason_DEALER_SOLD_SHORT_get, ShortSaleReason_DEALER_SOLD_SHORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ShortSaleReason_DEALERSOLDSHORTEXEMPT",ShortSaleReason_DEALERSOLDSHORTEXEMPT_get, ShortSaleReason_DEALERSOLDSHORTEXEMPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ShortSaleReason_QSR_OR_AGU_CONTRA_SIDE_SOLD_SHORT_EXEMPT",ShortSaleReason_QSR_OR_AGU_CONTRA_SIDE_SOLD_SHORT_EXEMPT_get, ShortSaleReason_QSR_OR_AGU_CONTRA_SIDE_SOLD_SHORT_EXEMPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ShortSaleReason_DEALERSOLDSHORT",ShortSaleReason_DEALERSOLDSHORT_get, ShortSaleReason_DEALERSOLDSHORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT",ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_get, ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_EXEMPT",ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_EXEMPT_get, ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_EXEMPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ShortSaleReason_SELLINGCUSTOMERSOLDSHORT",ShortSaleReason_SELLINGCUSTOMERSOLDSHORT_get, ShortSaleReason_SELLINGCUSTOMERSOLDSHORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ShortSaleReason_SELLINGCUSTOMERSOLDSHORTEXEMPT",ShortSaleReason_SELLINGCUSTOMERSOLDSHORTEXEMPT_get, ShortSaleReason_SELLINGCUSTOMERSOLDSHORTEXEMPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ShortSaleReason_DEALER_SOLD_SHORT_EXEMPT",ShortSaleReason_DEALER_SOLD_SHORT_EXEMPT_get, ShortSaleReason_DEALER_SOLD_SHORT_EXEMPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ShortSaleReason_QSRORAGUCONTRASIDESOLDSHORT",ShortSaleReason_QSRORAGUCONTRASIDESOLDSHORT_get, ShortSaleReason_QSRORAGUCONTRASIDESOLDSHORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ShortSaleReason_QUALIFIED_SERVICE_REPRESENTATIVE",ShortSaleReason_QUALIFIED_SERVICE_REPRESENTATIVE_get, ShortSaleReason_QUALIFIED_SERVICE_REPRESENTATIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ShortSaleReason_QSRORAGUCONTRASIDESOLDSHORTEXEMPT",ShortSaleReason_QSRORAGUCONTRASIDESOLDSHORTEXEMPT_get, ShortSaleReason_QSRORAGUCONTRASIDESOLDSHORTEXEMPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegRoundDirection_MOREPASSIVE",PegRoundDirection_MOREPASSIVE_get, PegRoundDirection_MOREPASSIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegRoundDirection_MOREAGGRESSIVE",PegRoundDirection_MOREAGGRESSIVE_get, PegRoundDirection_MOREAGGRESSIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegRoundDirection_MORE_AGGRESSIVE",PegRoundDirection_MORE_AGGRESSIVE_get, PegRoundDirection_MORE_AGGRESSIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegRoundDirection_MORE_PASSIVE",PegRoundDirection_MORE_PASSIVE_get, PegRoundDirection_MORE_PASSIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ModelType_PROPRIETARY",ModelType_PROPRIETARY_get, ModelType_PROPRIETARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ModelType_UTILITY_PROVIDED_STANDARD_MODEL",ModelType_UTILITY_PROVIDED_STANDARD_MODEL_get, ModelType_UTILITY_PROVIDED_STANDARD_MODEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FuturesValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT",FuturesValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT_get, FuturesValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FuturesValuationMethod_PREMIUM_STYLE",FuturesValuationMethod_PREMIUM_STYLE_get, FuturesValuationMethod_PREMIUM_STYLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FuturesValuationMethod_FUTURES_STYLE_MARK_TO_MARKET",FuturesValuationMethod_FUTURES_STYLE_MARK_TO_MARKET_get, FuturesValuationMethod_FUTURES_STYLE_MARK_TO_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlMethod_CASH_SETTLEMENT_REQUIRED",SettlMethod_CASH_SETTLEMENT_REQUIRED_get, SettlMethod_CASH_SETTLEMENT_REQUIRED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlMethod_PHYSICAL_SETTLEMENT_REQUIRED",SettlMethod_PHYSICAL_SETTLEMENT_REQUIRED_get, SettlMethod_PHYSICAL_SETTLEMENT_REQUIRED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmStatus_CONFIRMED",ConfirmStatus_CONFIRMED_get, ConfirmStatus_CONFIRMED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmStatus_REQUESTREJECTED",ConfirmStatus_REQUESTREJECTED_get, ConfirmStatus_REQUESTREJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmStatus_MISSINGSETTLEMENTINSTRUCTIONS",ConfirmStatus_MISSINGSETTLEMENTINSTRUCTIONS_get, ConfirmStatus_MISSINGSETTLEMENTINSTRUCTIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmStatus_MISSING_SETTLEMENT_INSTRUCTIONS",ConfirmStatus_MISSING_SETTLEMENT_INSTRUCTIONS_get, ConfirmStatus_MISSING_SETTLEMENT_INSTRUCTIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmStatus_REQUEST_REJECTED",ConfirmStatus_REQUEST_REJECTED_get, ConfirmStatus_REQUEST_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmStatus_MISMATCHEDACCOUNT",ConfirmStatus_MISMATCHEDACCOUNT_get, ConfirmStatus_MISMATCHEDACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmStatus_MISMATCHED_ACCOUNT",ConfirmStatus_MISMATCHED_ACCOUNT_get, ConfirmStatus_MISMATCHED_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmStatus_RECEIVED",ConfirmStatus_RECEIVED_get, ConfirmStatus_RECEIVED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LocateReqd_NO",LocateReqd_NO_get, LocateReqd_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LocateReqd_YES",LocateReqd_YES_get, LocateReqd_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Adjustment_CANCEL",Adjustment_CANCEL_get, Adjustment_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Adjustment_CORRECTION",Adjustment_CORRECTION_get, Adjustment_CORRECTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Adjustment_ERROR",Adjustment_ERROR_get, Adjustment_ERROR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StreamAsgnType_ASSIGNMENT",StreamAsgnType_ASSIGNMENT_get, StreamAsgnType_ASSIGNMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StreamAsgnType_TERMINATE_UNASSIGN",StreamAsgnType_TERMINATE_UNASSIGN_get, StreamAsgnType_TERMINATE_UNASSIGN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StreamAsgnType_REJECTED",StreamAsgnType_REJECTED_get, StreamAsgnType_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LastRptRequested_NO",LastRptRequested_NO_get, LastRptRequested_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LastRptRequested_YES",LastRptRequested_YES_get, LastRptRequested_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlSessID_END_OF_DAY",SettlSessID_END_OF_DAY_get, SettlSessID_END_OF_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlSessID_REGULAR_TRADING_HOURS",SettlSessID_REGULAR_TRADING_HOURS_get, SettlSessID_REGULAR_TRADING_HOURS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlSessID_ELECTRONIC_TRADING_HOURS",SettlSessID_ELECTRONIC_TRADING_HOURS_get, SettlSessID_ELECTRONIC_TRADING_HOURS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlSessID_INTRADAY",SettlSessID_INTRADAY_get, SettlSessID_INTRADAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_NO_WAS",TradeReportType_NO_WAS_get, TradeReportType_NO_WAS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_ADDENDUM",TradeReportType_ADDENDUM_get, TradeReportType_ADDENDUM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_7",TradeReportType_7_get, TradeReportType_7_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_PENDED",TradeReportType_PENDED_get, TradeReportType_PENDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_LOCKEDINTRADEBREAK",TradeReportType_LOCKEDINTRADEBREAK_get, TradeReportType_LOCKEDINTRADEBREAK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_DEFAULTED",TradeReportType_DEFAULTED_get, TradeReportType_DEFAULTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_DECLINE",TradeReportType_DECLINE_get, TradeReportType_DECLINE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_ALLEGED_NEW",TradeReportType_ALLEGED_NEW_get, TradeReportType_ALLEGED_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_ALLEGED_TRADE_REPORT_CANCEL",TradeReportType_ALLEGED_TRADE_REPORT_CANCEL_get, TradeReportType_ALLEGED_TRADE_REPORT_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_ALLEGED_15",TradeReportType_ALLEGED_15_get, TradeReportType_ALLEGED_15_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_ALLEGED_ADDENDUM",TradeReportType_ALLEGED_ADDENDUM_get, TradeReportType_ALLEGED_ADDENDUM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_ALLEGED",TradeReportType_ALLEGED_get, TradeReportType_ALLEGED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_SUBMIT",TradeReportType_SUBMIT_get, TradeReportType_SUBMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_NOWAS",TradeReportType_NOWAS_get, TradeReportType_NOWAS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_ALLEGED_1",TradeReportType_ALLEGED_1_get, TradeReportType_ALLEGED_1_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_INVALID_CMTA",TradeReportType_INVALID_CMTA_get, TradeReportType_INVALID_CMTA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_TRADEREPORTCANCEL",TradeReportType_TRADEREPORTCANCEL_get, TradeReportType_TRADEREPORTCANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_TRADE_REPORT_CANCEL",TradeReportType_TRADE_REPORT_CANCEL_get, TradeReportType_TRADE_REPORT_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_ALLEGED_NO_WAS",TradeReportType_ALLEGED_NO_WAS_get, TradeReportType_ALLEGED_NO_WAS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_ACCEPT",TradeReportType_ACCEPT_get, TradeReportType_ACCEPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExerciseStyle_AMERICAN",ExerciseStyle_AMERICAN_get, ExerciseStyle_AMERICAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExerciseStyle_EUROPEAN",ExerciseStyle_EUROPEAN_get, ExerciseStyle_EUROPEAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExerciseStyle_BERMUDA",ExerciseStyle_BERMUDA_get, ExerciseStyle_BERMUDA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HaltReasonChar_EQUIPCHANGE",HaltReasonChar_EQUIPCHANGE_get, HaltReasonChar_EQUIPCHANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HaltReasonChar_ADDITIONAL_INFORMATION",HaltReasonChar_ADDITIONAL_INFORMATION_get, HaltReasonChar_ADDITIONAL_INFORMATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HaltReasonChar_ORDINFL",HaltReasonChar_ORDINFL_get, HaltReasonChar_ORDINFL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HaltReasonChar_NEW_PENDING",HaltReasonChar_NEW_PENDING_get, HaltReasonChar_NEW_PENDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HaltReasonChar_NEWSDISS",HaltReasonChar_NEWSDISS_get, HaltReasonChar_NEWSDISS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HaltReasonChar_NEWS_PENDING",HaltReasonChar_NEWS_PENDING_get, HaltReasonChar_NEWS_PENDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HaltReasonChar_ORDER_INFLUX",HaltReasonChar_ORDER_INFLUX_get, HaltReasonChar_ORDER_INFLUX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HaltReasonChar_NEWS_DISSEMINATION",HaltReasonChar_NEWS_DISSEMINATION_get, HaltReasonChar_NEWS_DISSEMINATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HaltReasonChar_ADDINFO",HaltReasonChar_ADDINFO_get, HaltReasonChar_ADDINFO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HaltReasonChar_ORDIMB",HaltReasonChar_ORDIMB_get, HaltReasonChar_ORDIMB_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HaltReasonChar_EQUIPMENT_CHANGEOVER",HaltReasonChar_EQUIPMENT_CHANGEOVER_get, HaltReasonChar_EQUIPMENT_CHANGEOVER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HaltReasonChar_ORDER_IMBALANCE",HaltReasonChar_ORDER_IMBALANCE_get, HaltReasonChar_ORDER_IMBALANCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HaltReasonChar_NEWSPEND",HaltReasonChar_NEWSPEND_get, HaltReasonChar_NEWSPEND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExDestination_POSIT",ExDestination_POSIT_get, ExDestination_POSIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExDestination_NONE",ExDestination_NONE_get, ExDestination_NONE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocReportType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY",AllocReportType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY_get, AllocReportType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocReportType_WAREHOUSE_RECAP",AllocReportType_WAREHOUSE_RECAP_get, AllocReportType_WAREHOUSE_RECAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocReportType_REJECT",AllocReportType_REJECT_get, AllocReportType_REJECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocReportType_REQUESTTOINTERMEDIARY",AllocReportType_REQUESTTOINTERMEDIARY_get, AllocReportType_REQUESTTOINTERMEDIARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocReportType_ACCEPT_PENDING",AllocReportType_ACCEPT_PENDING_get, AllocReportType_ACCEPT_PENDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocReportType_REQUEST_TO_INTERMEDIARY",AllocReportType_REQUEST_TO_INTERMEDIARY_get, AllocReportType_REQUEST_TO_INTERMEDIARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocReportType_COMPLETE",AllocReportType_COMPLETE_get, AllocReportType_COMPLETE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocReportType_SELLSIDECALCULATEDUSINGPRELIMINARY",AllocReportType_SELLSIDECALCULATEDUSINGPRELIMINARY_get, AllocReportType_SELLSIDECALCULATEDUSINGPRELIMINARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocReportType_PRELIMINARY_REQUEST_TO_INTERMEDIARY",AllocReportType_PRELIMINARY_REQUEST_TO_INTERMEDIARY_get, AllocReportType_PRELIMINARY_REQUEST_TO_INTERMEDIARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocReportType_SELLSIDE_CALCULATED_USING_PRELIMINARY",AllocReportType_SELLSIDE_CALCULATED_USING_PRELIMINARY_get, AllocReportType_SELLSIDE_CALCULATED_USING_PRELIMINARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocReportType_REVERSE_PENDING",AllocReportType_REVERSE_PENDING_get, AllocReportType_REVERSE_PENDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocReportType_WAREHOUSERECAP",AllocReportType_WAREHOUSERECAP_get, AllocReportType_WAREHOUSERECAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocReportType_ACCEPT",AllocReportType_ACCEPT_get, AllocReportType_ACCEPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocReportType_SELLSIDECALCULATEDWITHOUTPRELIMINARY",AllocReportType_SELLSIDECALCULATEDWITHOUTPRELIMINARY_get, AllocReportType_SELLSIDECALCULATEDWITHOUTPRELIMINARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_BUYSIDEREADYTOBOOKSINGLE",AllocType_BUYSIDEREADYTOBOOKSINGLE_get, AllocType_BUYSIDEREADYTOBOOKSINGLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY",AllocType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY_get, AllocType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_CALCULATED",AllocType_CALCULATED_get, AllocType_CALCULATED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_INCOMPLETE_GROUP",AllocType_INCOMPLETE_GROUP_get, AllocType_INCOMPLETE_GROUP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_REVERSAL_PENDING",AllocType_REVERSAL_PENDING_get, AllocType_REVERSAL_PENDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_PRELIMINARY",AllocType_PRELIMINARY_get, AllocType_PRELIMINARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_REJECT",AllocType_REJECT_get, AllocType_REJECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_WAREHOUSEINSTRUCTION",AllocType_WAREHOUSEINSTRUCTION_get, AllocType_WAREHOUSEINSTRUCTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_BUYSIDEPRELIM",AllocType_BUYSIDEPRELIM_get, AllocType_BUYSIDEPRELIM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_REQUESTTOINTERMEDIARY",AllocType_REQUESTTOINTERMEDIARY_get, AllocType_REQUESTTOINTERMEDIARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_ACCEPT_PENDING",AllocType_ACCEPT_PENDING_get, AllocType_ACCEPT_PENDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_BUYSIDEREADYTOBOOKCOMBINED",AllocType_BUYSIDEREADYTOBOOKCOMBINED_get, AllocType_BUYSIDEREADYTOBOOKCOMBINED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_BUYSIDE_CALCULATED",AllocType_BUYSIDE_CALCULATED_get, AllocType_BUYSIDE_CALCULATED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_REQUEST_TO_INTERMEDIARY",AllocType_REQUEST_TO_INTERMEDIARY_get, AllocType_REQUEST_TO_INTERMEDIARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_SELLSIDECALCWITHOUTPRELIM",AllocType_SELLSIDECALCWITHOUTPRELIM_get, AllocType_SELLSIDECALCWITHOUTPRELIM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_BUYSIDE_READY_TO_BOOK_5",AllocType_BUYSIDE_READY_TO_BOOK_5_get, AllocType_BUYSIDE_READY_TO_BOOK_5_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_BUYSIDE_READY_TO_BOOK_6",AllocType_BUYSIDE_READY_TO_BOOK_6_get, AllocType_BUYSIDE_READY_TO_BOOK_6_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_COMPLETE_GROUP",AllocType_COMPLETE_GROUP_get, AllocType_COMPLETE_GROUP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_BUYSIDECALC",AllocType_BUYSIDECALC_get, AllocType_BUYSIDECALC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_SELLSIDE_CALCULATED_USING_PRELIMINARY",AllocType_SELLSIDE_CALCULATED_USING_PRELIMINARY_get, AllocType_SELLSIDE_CALCULATED_USING_PRELIMINARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_READY_TO_BOOK",AllocType_READY_TO_BOOK_get, AllocType_READY_TO_BOOK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_BUYSIDE_READY_TO_BOOK",AllocType_BUYSIDE_READY_TO_BOOK_get, AllocType_BUYSIDE_READY_TO_BOOK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_WAREHOUSE_INSTRUCTION",AllocType_WAREHOUSE_INSTRUCTION_get, AllocType_WAREHOUSE_INSTRUCTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_BUYSIDE_PRELIMINARY",AllocType_BUYSIDE_PRELIMINARY_get, AllocType_BUYSIDE_PRELIMINARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_ACCEPT",AllocType_ACCEPT_get, AllocType_ACCEPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_SELLSIDECALC",AllocType_SELLSIDECALC_get, AllocType_SELLSIDECALC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_INSUFFICIENT_CREDIT",QuoteRequestRejectReason_INSUFFICIENT_CREDIT_get, QuoteRequestRejectReason_INSUFFICIENT_CREDIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_NOMARKETFORINSTRUMENT",QuoteRequestRejectReason_NOMARKETFORINSTRUMENT_get, QuoteRequestRejectReason_NOMARKETFORINSTRUMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_NOTAUTHTOREQQUOTE",QuoteRequestRejectReason_NOTAUTHTOREQQUOTE_get, QuoteRequestRejectReason_NOTAUTHTOREQQUOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_NOT_AUTHORIZED_TO_REQUEST_QUOTE",QuoteRequestRejectReason_NOT_AUTHORIZED_TO_REQUEST_QUOTE_get, QuoteRequestRejectReason_NOT_AUTHORIZED_TO_REQUEST_QUOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_QUOTEREQUESTEXLIMIT",QuoteRequestRejectReason_QUOTEREQUESTEXLIMIT_get, QuoteRequestRejectReason_QUOTEREQUESTEXLIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_INVALID_PRICE",QuoteRequestRejectReason_INVALID_PRICE_get, QuoteRequestRejectReason_INVALID_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_EXCHANGECLOSED",QuoteRequestRejectReason_EXCHANGECLOSED_get, QuoteRequestRejectReason_EXCHANGECLOSED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_TOOLATE",QuoteRequestRejectReason_TOOLATE_get, QuoteRequestRejectReason_TOOLATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_INVPRICE",QuoteRequestRejectReason_INVPRICE_get, QuoteRequestRejectReason_INVPRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_NOMATCHFORINQUIRY",QuoteRequestRejectReason_NOMATCHFORINQUIRY_get, QuoteRequestRejectReason_NOMATCHFORINQUIRY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_TOO_LATE_TO_ENTER",QuoteRequestRejectReason_TOO_LATE_TO_ENTER_get, QuoteRequestRejectReason_TOO_LATE_TO_ENTER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_NO_MATCH_FOR_INQUIRY",QuoteRequestRejectReason_NO_MATCH_FOR_INQUIRY_get, QuoteRequestRejectReason_NO_MATCH_FOR_INQUIRY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_UNKNOWNSYM",QuoteRequestRejectReason_UNKNOWNSYM_get, QuoteRequestRejectReason_UNKNOWNSYM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_EXCHANGE",QuoteRequestRejectReason_EXCHANGE_get, QuoteRequestRejectReason_EXCHANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_NO_MARKET_FOR_INSTRUMENT",QuoteRequestRejectReason_NO_MARKET_FOR_INSTRUMENT_get, QuoteRequestRejectReason_NO_MARKET_FOR_INSTRUMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_UNKNOWN_SYMBOL",QuoteRequestRejectReason_UNKNOWN_SYMBOL_get, QuoteRequestRejectReason_UNKNOWN_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_OTHER",QuoteRequestRejectReason_OTHER_get, QuoteRequestRejectReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_PASS",QuoteRequestRejectReason_PASS_get, QuoteRequestRejectReason_PASS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_NOINVENTORY",QuoteRequestRejectReason_NOINVENTORY_get, QuoteRequestRejectReason_NOINVENTORY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_NO_INVENTORY",QuoteRequestRejectReason_NO_INVENTORY_get, QuoteRequestRejectReason_NO_INVENTORY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT",QuoteRequestRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT_get, QuoteRequestRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LiquidityIndType_5DAY",LiquidityIndType_5DAY_get, LiquidityIndType_5DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LiquidityIndType_NORMAL",LiquidityIndType_NORMAL_get, LiquidityIndType_NORMAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LiquidityIndType_20_DAY_MOVING_AVERAGE",LiquidityIndType_20_DAY_MOVING_AVERAGE_get, LiquidityIndType_20_DAY_MOVING_AVERAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LiquidityIndType_5_DAY_MOVING_AVERAGE",LiquidityIndType_5_DAY_MOVING_AVERAGE_get, LiquidityIndType_5_DAY_MOVING_AVERAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LiquidityIndType_5DAY_MOVING_AVERAGE",LiquidityIndType_5DAY_MOVING_AVERAGE_get, LiquidityIndType_5DAY_MOVING_AVERAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LiquidityIndType_NORMAL_MARKET_SIZE",LiquidityIndType_NORMAL_MARKET_SIZE_get, LiquidityIndType_NORMAL_MARKET_SIZE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LiquidityIndType_OTHER",LiquidityIndType_OTHER_get, LiquidityIndType_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LiquidityIndType_20DAY",LiquidityIndType_20DAY_get, LiquidityIndType_20DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StatusValue_IN_PROCESS",StatusValue_IN_PROCESS_get, StatusValue_IN_PROCESS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StatusValue_NOTCONNECTEDDOWNEXPECTEDUP",StatusValue_NOTCONNECTEDDOWNEXPECTEDUP_get, StatusValue_NOTCONNECTEDDOWNEXPECTEDUP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StatusValue_NOT_CONNECTED_2",StatusValue_NOT_CONNECTED_2_get, StatusValue_NOT_CONNECTED_2_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StatusValue_NOTCONNECTEDDOWNEXPECTEDDOWN",StatusValue_NOTCONNECTEDDOWNEXPECTEDDOWN_get, StatusValue_NOTCONNECTEDDOWNEXPECTEDDOWN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StatusValue_CONNECTED",StatusValue_CONNECTED_get, StatusValue_CONNECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StatusValue_NOT_CONNECTED_3",StatusValue_NOT_CONNECTED_3_get, StatusValue_NOT_CONNECTED_3_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StatusValue_INPROCESS",StatusValue_INPROCESS_get, StatusValue_INPROCESS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_INTRA_SPREAD_QTY",PosType_INTRA_SPREAD_QTY_get, PosType_INTRA_SPREAD_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_INTER_SPREAD_QTY",PosType_INTER_SPREAD_QTY_get, PosType_INTER_SPREAD_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_TRANSFER_TRADE_QTY",PosType_TRANSFER_TRADE_QTY_get, PosType_TRANSFER_TRADE_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_EXCHANGE_FOR_PHYSICAL_QTY",PosType_EXCHANGE_FOR_PHYSICAL_QTY_get, PosType_EXCHANGE_FOR_PHYSICAL_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_TRANSFERTRADEQTY",PosType_TRANSFERTRADEQTY_get, PosType_TRANSFERTRADEQTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_TRANSACTIONQUANTITY",PosType_TRANSACTIONQUANTITY_get, PosType_TRANSACTIONQUANTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_ADJUSTMENTQTY",PosType_ADJUSTMENTQTY_get, PosType_ADJUSTMENTQTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_START_OF_DAY_QTY",PosType_START_OF_DAY_QTY_get, PosType_START_OF_DAY_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_ENDOFDAYQTY",PosType_ENDOFDAYQTY_get, PosType_ENDOFDAYQTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_DELIVERY_QTY",PosType_DELIVERY_QTY_get, PosType_DELIVERY_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_TRANSACTIONFROMEXERCISE",PosType_TRANSACTIONFROMEXERCISE_get, PosType_TRANSACTIONFROMEXERCISE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_OPTIONEXERCISEQTY",PosType_OPTIONEXERCISEQTY_get, PosType_OPTIONEXERCISEQTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_DELIVERYQTY",PosType_DELIVERYQTY_get, PosType_DELIVERYQTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_OPTION_ASSIGNMENT",PosType_OPTION_ASSIGNMENT_get, PosType_OPTION_ASSIGNMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_PIT_TRADE_QTY",PosType_PIT_TRADE_QTY_get, PosType_PIT_TRADE_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_TRANSACTION_FROM_ASSIGNMENT",PosType_TRANSACTION_FROM_ASSIGNMENT_get, PosType_TRANSACTION_FROM_ASSIGNMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_TRANSACTION_FROM_EXERCISE",PosType_TRANSACTION_FROM_EXERCISE_get, PosType_TRANSACTION_FROM_EXERCISE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_INTEGRALSPLIT",PosType_INTEGRALSPLIT_get, PosType_INTEGRALSPLIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_ELECTRONICTRADEQTY",PosType_ELECTRONICTRADEQTY_get, PosType_ELECTRONICTRADEQTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_AS_OF_TRADE_QTY",PosType_AS_OF_TRADE_QTY_get, PosType_AS_OF_TRADE_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_ELECTRONIC_TRADE_QTY",PosType_ELECTRONIC_TRADE_QTY_get, PosType_ELECTRONIC_TRADE_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_PITTRADEQTY",PosType_PITTRADEQTY_get, PosType_PITTRADEQTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_OPTIONASSIGNMENT",PosType_OPTIONASSIGNMENT_get, PosType_OPTIONASSIGNMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_SUCCESSION_EVENT_ADJUSTMENT",PosType_SUCCESSION_EVENT_ADJUSTMENT_get, PosType_SUCCESSION_EVENT_ADJUSTMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_OPTION_EXERCISE_QTY",PosType_OPTION_EXERCISE_QTY_get, PosType_OPTION_EXERCISE_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_TRANSACTION_QUANTITY",PosType_TRANSACTION_QUANTITY_get, PosType_TRANSACTION_QUANTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_NET_DELTA_QTY",PosType_NET_DELTA_QTY_get, PosType_NET_DELTA_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_END_OF_DAY_QTY",PosType_END_OF_DAY_QTY_get, PosType_END_OF_DAY_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_ADJUSTMENT_QTY",PosType_ADJUSTMENT_QTY_get, PosType_ADJUSTMENT_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_TOTAL_TRANSACTION_QTY",PosType_TOTAL_TRANSACTION_QTY_get, PosType_TOTAL_TRANSACTION_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_DELIVERY_NOTICE_QTY",PosType_DELIVERY_NOTICE_QTY_get, PosType_DELIVERY_NOTICE_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_RECEIVE_QUANTITY",PosType_RECEIVE_QUANTITY_get, PosType_RECEIVE_QUANTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_ASOFTRADEQTY",PosType_ASOFTRADEQTY_get, PosType_ASOFTRADEQTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_ALLOCATIONTRADEQTY",PosType_ALLOCATIONTRADEQTY_get, PosType_ALLOCATIONTRADEQTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_CREDIT_EVENT_ADJUSTMENT",PosType_CREDIT_EVENT_ADJUSTMENT_get, PosType_CREDIT_EVENT_ADJUSTMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_PRIVATELY_NEGOTIATED_TRADE_QTY",PosType_PRIVATELY_NEGOTIATED_TRADE_QTY_get, PosType_PRIVATELY_NEGOTIATED_TRADE_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_CROSS_MARGIN_QTY",PosType_CROSS_MARGIN_QTY_get, PosType_CROSS_MARGIN_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_CORPORATE_ACTION_ADJUSTMENT",PosType_CORPORATE_ACTION_ADJUSTMENT_get, PosType_CORPORATE_ACTION_ADJUSTMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_TOTALTRANSACTIONQTY",PosType_TOTALTRANSACTIONQTY_get, PosType_TOTALTRANSACTIONQTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_STARTOFDAYQTY",PosType_STARTOFDAYQTY_get, PosType_STARTOFDAYQTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_INTEGRAL_SPLIT",PosType_INTEGRAL_SPLIT_get, PosType_INTEGRAL_SPLIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_INTERSPREADQTY",PosType_INTERSPREADQTY_get, PosType_INTERSPREADQTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_INTRASPREADQTY",PosType_INTRASPREADQTY_get, PosType_INTRASPREADQTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_ALLOCATION_TRADE_QTY",PosType_ALLOCATION_TRADE_QTY_get, PosType_ALLOCATION_TRADE_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_CROSSMARGINQTY",PosType_CROSSMARGINQTY_get, PosType_CROSSMARGINQTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_TRANSACTIONFROMASSIGNMENT",PosType_TRANSACTIONFROMASSIGNMENT_get, PosType_TRANSACTIONFROMASSIGNMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StreamAsgnAckType_ASSIGNMENT_REJECTED",StreamAsgnAckType_ASSIGNMENT_REJECTED_get, StreamAsgnAckType_ASSIGNMENT_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StreamAsgnAckType_ASSIGNMENT_ACCEPTED",StreamAsgnAckType_ASSIGNMENT_ACCEPTED_get, StreamAsgnAckType_ASSIGNMENT_ACCEPTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RiskInstrumentOperator_EXCLUDE",RiskInstrumentOperator_EXCLUDE_get, RiskInstrumentOperator_EXCLUDE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RiskInstrumentOperator_INCLUDE",RiskInstrumentOperator_INCLUDE_get, RiskInstrumentOperator_INCLUDE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeBasis_PERUNIT",MiscFeeBasis_PERUNIT_get, MiscFeeBasis_PERUNIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeBasis_ABSOLUTE",MiscFeeBasis_ABSOLUTE_get, MiscFeeBasis_ABSOLUTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeBasis_PERCENTAGE",MiscFeeBasis_PERCENTAGE_get, MiscFeeBasis_PERCENTAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeBasis_PER_UNIT",MiscFeeBasis_PER_UNIT_get, MiscFeeBasis_PER_UNIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_FOREX_MARKET",OrdType_FOREX_MARKET_get, OrdType_FOREX_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_FOREX_PREVIOUSLY_QUOTED",OrdType_FOREX_PREVIOUSLY_QUOTED_get, OrdType_FOREX_PREVIOUSLY_QUOTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_ONBASIS",OrdType_ONBASIS_get, OrdType_ONBASIS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_PREVIOUSLYINDICATED",OrdType_PREVIOUSLYINDICATED_get, OrdType_PREVIOUSLYINDICATED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_PREVIOUS_FUND_VALUATION_POINT",OrdType_PREVIOUS_FUND_VALUATION_POINT_get, OrdType_PREVIOUS_FUND_VALUATION_POINT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_PEGGED",OrdType_PEGGED_get, OrdType_PEGGED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_LIMITONCLOSE",OrdType_LIMITONCLOSE_get, OrdType_LIMITONCLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_LIMIT_WITH_OR_WITHOUT",OrdType_LIMIT_WITH_OR_WITHOUT_get, OrdType_LIMIT_WITH_OR_WITHOUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_STOP_LIMIT",OrdType_STOP_LIMIT_get, OrdType_STOP_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_FOREX_SWAP",OrdType_FOREX_SWAP_get, OrdType_FOREX_SWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_WITHORWITHOUT",OrdType_WITHORWITHOUT_get, OrdType_WITHORWITHOUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_FOREXLIMIT",OrdType_FOREXLIMIT_get, OrdType_FOREXLIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_MARKET_WITH_LEFT_OVER_AS_LIMIT",OrdType_MARKET_WITH_LEFT_OVER_AS_LIMIT_get, OrdType_MARKET_WITH_LEFT_OVER_AS_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_PREVIOUSLYQUOTED",OrdType_PREVIOUSLYQUOTED_get, OrdType_PREVIOUSLYQUOTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_PREVIOUSLY_QUOTED",OrdType_PREVIOUSLY_QUOTED_get, OrdType_PREVIOUSLY_QUOTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_COUNTER_ORDER_SELECTION",OrdType_COUNTER_ORDER_SELECTION_get, OrdType_COUNTER_ORDER_SELECTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_LIMITWITHORWITHOUT",OrdType_LIMITWITHORWITHOUT_get, OrdType_LIMITWITHORWITHOUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_FOREXSWAP",OrdType_FOREXSWAP_get, OrdType_FOREXSWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_MARKET_IF_TOUCHED",OrdType_MARKET_IF_TOUCHED_get, OrdType_MARKET_IF_TOUCHED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_NEXT_FUND_VALUATION_POINT",OrdType_NEXT_FUND_VALUATION_POINT_get, OrdType_NEXT_FUND_VALUATION_POINT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_FOREX_C",OrdType_FOREX_C_get, OrdType_FOREX_C_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_ON_CLOSE",OrdType_ON_CLOSE_get, OrdType_ON_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_STOP",OrdType_STOP_get, OrdType_STOP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_STOPLIMIT",OrdType_STOPLIMIT_get, OrdType_STOPLIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_LIMITORBETTER",OrdType_LIMITORBETTER_get, OrdType_LIMITORBETTER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_ONCLOSE",OrdType_ONCLOSE_get, OrdType_ONCLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_FOREX_LIMIT",OrdType_FOREX_LIMIT_get, OrdType_FOREX_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_FOREXMARKET",OrdType_FOREXMARKET_get, OrdType_FOREXMARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_FOREX",OrdType_FOREX_get, OrdType_FOREX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_MARKETIFTOUCHED",OrdType_MARKETIFTOUCHED_get, OrdType_MARKETIFTOUCHED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_FUNARI",OrdType_FUNARI_get, OrdType_FUNARI_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_FOREX_F",OrdType_FOREX_F_get, OrdType_FOREX_F_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_PREVIOUSLY_INDICATED",OrdType_PREVIOUSLY_INDICATED_get, OrdType_PREVIOUSLY_INDICATED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_WITH_OR_WITHOUT",OrdType_WITH_OR_WITHOUT_get, OrdType_WITH_OR_WITHOUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_MARKET_ON_CLOSE",OrdType_MARKET_ON_CLOSE_get, OrdType_MARKET_ON_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_LIMIT",OrdType_LIMIT_get, OrdType_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_MARKET_WITH_LEFTOVER_AS_LIMIT",OrdType_MARKET_WITH_LEFTOVER_AS_LIMIT_get, OrdType_MARKET_WITH_LEFTOVER_AS_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_FOREX_G",OrdType_FOREX_G_get, OrdType_FOREX_G_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_LIMIT_ON_CLOSE",OrdType_LIMIT_ON_CLOSE_get, OrdType_LIMIT_ON_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_MARKETONCLOSE",OrdType_MARKETONCLOSE_get, OrdType_MARKETONCLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_PREVIOUSFUNDVALUATIONPOINT",OrdType_PREVIOUSFUNDVALUATIONPOINT_get, OrdType_PREVIOUSFUNDVALUATIONPOINT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_NEXTFUNDVALUATIONPOINT",OrdType_NEXTFUNDVALUATIONPOINT_get, OrdType_NEXTFUNDVALUATIONPOINT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_FOREX_H",OrdType_FOREX_H_get, OrdType_FOREX_H_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_FOREXPREVIOUSLYQUOTED",OrdType_FOREXPREVIOUSLYQUOTED_get, OrdType_FOREXPREVIOUSLYQUOTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_MARKETWITHLEFTOVERLIMIT",OrdType_MARKETWITHLEFTOVERLIMIT_get, OrdType_MARKETWITHLEFTOVERLIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_ON_BASIS",OrdType_ON_BASIS_get, OrdType_ON_BASIS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_LIMIT_OR_BETTER",OrdType_LIMIT_OR_BETTER_get, OrdType_LIMIT_OR_BETTER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_MARKET",OrdType_MARKET_get, OrdType_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_ACT_DEFAULT_AFTER_M2",MatchType_ACT_DEFAULT_AFTER_M2_get, MatchType_ACT_DEFAULT_AFTER_M2_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_SUMMARIZEDMATCHUSINGA2",MatchType_SUMMARIZEDMATCHUSINGA2_get, MatchType_SUMMARIZEDMATCHUSINGA2_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_COUNTER_ORDER_SELECTION_6",MatchType_COUNTER_ORDER_SELECTION_6_get, MatchType_COUNTER_ORDER_SELECTION_6_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND",MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_get, MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_SUMMARIZED_MATCH_USING_A4_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED",MatchType_SUMMARIZED_MATCH_USING_A4_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_get, MatchType_SUMMARIZED_MATCH_USING_A4_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_NON_ACT",MatchType_NON_ACT_get, MatchType_NON_ACT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_SUMMARIZEDMATCHUSINGA3",MatchType_SUMMARIZEDMATCHUSINGA3_get, MatchType_SUMMARIZEDMATCHUSINGA3_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S1",MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S1_get, MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S1_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_SUMMARIZED_MATCH_MINUS_BADGES_AND_TIMES_ACT_M2_MATCH",MatchType_SUMMARIZED_MATCH_MINUS_BADGES_AND_TIMES_ACT_M2_MATCH_get, MatchType_SUMMARIZED_MATCH_MINUS_BADGES_AND_TIMES_ACT_M2_MATCH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_SUMMARIZEDMATCHUSINGA4",MatchType_SUMMARIZEDMATCHUSINGA4_get, MatchType_SUMMARIZEDMATCHUSINGA4_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S2",MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S2_get, MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S2_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_TWO_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT",MatchType_TWO_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT_get, MatchType_TWO_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_SUMMARIZEDMATCHUSINGA5",MatchType_SUMMARIZEDMATCHUSINGA5_get, MatchType_SUMMARIZEDMATCHUSINGA5_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_NASDAQACTM2MATCH",MatchType_NASDAQACTM2MATCH_get, MatchType_NASDAQACTM2MATCH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_CROSS_AUCTION_5",MatchType_CROSS_AUCTION_5_get, MatchType_CROSS_AUCTION_5_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_ACT_M1_MATCH",MatchType_ACT_M1_MATCH_get, MatchType_ACT_M1_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",MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_TWO_BADGES_get, 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_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S3",MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S3_get, MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S3_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSTWOBADGES",MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSTWOBADGES_get, MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSTWOBADGES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_NASDAQACTDEFAULTAFTERM2",MatchType_NASDAQACTDEFAULTAFTERM2_get, MatchType_NASDAQACTDEFAULTAFTERM2_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSFOURBADGES",MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSFOURBADGES_get, MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSFOURBADGES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_NASDAQACTM1MATCH",MatchType_NASDAQACTM1MATCH_get, MatchType_NASDAQACTM1MATCH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_CALL_AUCTION_7",MatchType_CALL_AUCTION_7_get, MatchType_CALL_AUCTION_7_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_CROSS_AUCTION_63",MatchType_CROSS_AUCTION_63_get, MatchType_CROSS_AUCTION_63_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_ISSUING_BUY_BACK_AUCTION",MatchType_ISSUING_BUY_BACK_AUCTION_get, MatchType_ISSUING_BUY_BACK_AUCTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S4",MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S4_get, MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S4_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",MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_EXECUTION_TIME_get, 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_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSFOURBADGESANDEXECUTIONTIME",MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSFOURBADGESANDEXECUTIONTIME_get, MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSFOURBADGESANDEXECUTIONTIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_ONE_PARTY_TRADE_REPORT",MatchType_ONE_PARTY_TRADE_REPORT_get, MatchType_ONE_PARTY_TRADE_REPORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S5",MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S5_get, MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S5_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_ACT_M2_MATCH",MatchType_ACT_M2_MATCH_get, MatchType_ACT_M2_MATCH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_SUMMARIZEDMATCHMINUSBADGESANDTIMES",MatchType_SUMMARIZEDMATCHMINUSBADGESANDTIMES_get, MatchType_SUMMARIZEDMATCHMINUSBADGESANDTIMES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_NASDAQACTDEFAULTTRADE",MatchType_NASDAQACTDEFAULTTRADE_get, MatchType_NASDAQACTDEFAULTTRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_CALL_AUCTION",MatchType_CALL_AUCTION_get, MatchType_CALL_AUCTION_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",MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_MINUS_BADGES_AND_TIMES_ACT_M1_MATCH_get, 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_ACT_ACCEPTED_TRADE",MatchType_ACT_ACCEPTED_TRADE_get, MatchType_ACT_ACCEPTED_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_TWO_PARTY_TRADE_REPORT",MatchType_TWO_PARTY_TRADE_REPORT_get, MatchType_TWO_PARTY_TRADE_REPORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_SUMMARIZED_MATCH_USING_A1_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIED",MatchType_SUMMARIZED_MATCH_USING_A1_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIED_get, MatchType_SUMMARIZED_MATCH_USING_A1_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_CONTINUOUS_AUTO_MATCH",MatchType_CONTINUOUS_AUTO_MATCH_get, MatchType_CONTINUOUS_AUTO_MATCH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_ONE_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT",MatchType_ONE_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT_get, MatchType_ONE_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_ACT_M6_MATCH",MatchType_ACT_M6_MATCH_get, MatchType_ACT_M6_MATCH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_SUMMARIZED_MATCH_USING_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED",MatchType_SUMMARIZED_MATCH_USING_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_get, MatchType_SUMMARIZED_MATCH_USING_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_ACT_DEFAULT_TRADE",MatchType_ACT_DEFAULT_TRADE_get, MatchType_ACT_DEFAULT_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORMINUSBADGESANDTIMES",MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORMINUSBADGESANDTIMES_get, MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORMINUSBADGESANDTIMES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST",MatchType_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST_get, MatchType_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_AUTO_MATCH",MatchType_AUTO_MATCH_get, MatchType_AUTO_MATCH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_NASDAQACTM6MATCH",MatchType_NASDAQACTM6MATCH_get, MatchType_NASDAQACTM6MATCH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_OCSLOCKEDIN",MatchType_OCSLOCKEDIN_get, MatchType_OCSLOCKEDIN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_COUNTER_ORDER_SELECTION",MatchType_COUNTER_ORDER_SELECTION_get, MatchType_COUNTER_ORDER_SELECTION_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",MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_FOUR_BADGES_get, 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_SUMMARIZED_MATCH_USING_A3_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED",MatchType_SUMMARIZED_MATCH_USING_A3_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_get, MatchType_SUMMARIZED_MATCH_USING_A3_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_NASDAQACTACCEPTEDTRADE",MatchType_NASDAQACTACCEPTEDTRADE_get, MatchType_NASDAQACTACCEPTEDTRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_CALL_AUCTION_65",MatchType_CALL_AUCTION_65_get, MatchType_CALL_AUCTION_65_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_CROSS_AUCTION",MatchType_CROSS_AUCTION_get, MatchType_CROSS_AUCTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_OCS_LOCKED_IN_NON_ACT",MatchType_OCS_LOCKED_IN_NON_ACT_get, MatchType_OCS_LOCKED_IN_NON_ACT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_CONFIRMED_TRADE_REPORT",MatchType_CONFIRMED_TRADE_REPORT_get, MatchType_CONFIRMED_TRADE_REPORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADETYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_EXECUTION_TIME",MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADETYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_EXECUTION_TIME_get, 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_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSTWOBADGESANDEXECUTIONTIME",MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSTWOBADGESANDEXECUTIONTIME_get, MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSTWOBADGESANDEXECUTIONTIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_SUMMARIZED_MATCH_USING_A2_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED",MatchType_SUMMARIZED_MATCH_USING_A2_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_get, MatchType_SUMMARIZED_MATCH_USING_A2_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSEXECUTIONTIME",MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSEXECUTIONTIME_get, MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSEXECUTIONTIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_NASDAQNONACT",MatchType_NASDAQNONACT_get, MatchType_NASDAQNONACT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_COMPAREDRECORDSRESULTINGFROMSTAMPEDADVISORIESORSPECIALISTACCEPTSPAIROFFS",MatchType_COMPAREDRECORDSRESULTINGFROMSTAMPEDADVISORIESORSPECIALISTACCEPTSPAIROFFS_get, MatchType_COMPAREDRECORDSRESULTINGFROMSTAMPEDADVISORIESORSPECIALISTACCEPTSPAIROFFS_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",MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_TWO_BADGES_AND_EXECUTION_TIME_get, 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_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST_ACCEPTS_PAIR_OFFS",MatchType_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST_ACCEPTS_PAIR_OFFS_get, MatchType_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST_ACCEPTS_PAIR_OFFS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_SUMMARIZEDMATCHUSINGA1",MatchType_SUMMARIZEDMATCHUSINGA1_get, MatchType_SUMMARIZEDMATCHUSINGA1_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",MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_FOUR_BADGES_AND_EXECUTION_TIME_get, 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_COUNTER_ORDER_SELECTION_64",MatchType_COUNTER_ORDER_SELECTION_64_get, MatchType_COUNTER_ORDER_SELECTION_64_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OptPayoutType_BINARY",OptPayoutType_BINARY_get, OptPayoutType_BINARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OptPayoutType_VANILLA",OptPayoutType_VANILLA_get, OptPayoutType_VANILLA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OptPayoutType_CAPPED",OptPayoutType_CAPPED_get, OptPayoutType_CAPPED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MarketUpdateAction_DELETE",MarketUpdateAction_DELETE_get, MarketUpdateAction_DELETE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MarketUpdateAction_ADD",MarketUpdateAction_ADD_get, MarketUpdateAction_ADD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MarketUpdateAction_MODIFY",MarketUpdateAction_MODIFY_get, MarketUpdateAction_MODIFY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnRejectReason_INVALIDTYPEOFCOLLATERAL",CollAsgnRejectReason_INVALIDTYPEOFCOLLATERAL_get, CollAsgnRejectReason_INVALIDTYPEOFCOLLATERAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnRejectReason_UNAUTHORIZED_TRANSACTION",CollAsgnRejectReason_UNAUTHORIZED_TRANSACTION_get, CollAsgnRejectReason_UNAUTHORIZED_TRANSACTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnRejectReason_UNKNOWN_OR_INVALID_INSTRUMENT",CollAsgnRejectReason_UNKNOWN_OR_INVALID_INSTRUMENT_get, CollAsgnRejectReason_UNKNOWN_OR_INVALID_INSTRUMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnRejectReason_UNKNOWNDEAL",CollAsgnRejectReason_UNKNOWNDEAL_get, CollAsgnRejectReason_UNKNOWNDEAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnRejectReason_UNKNOWN_DEAL",CollAsgnRejectReason_UNKNOWN_DEAL_get, CollAsgnRejectReason_UNKNOWN_DEAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnRejectReason_UNAUTHORIZEDTRANSACTION",CollAsgnRejectReason_UNAUTHORIZEDTRANSACTION_get, CollAsgnRejectReason_UNAUTHORIZEDTRANSACTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnRejectReason_INVALID_TYPE_OF_COLLATERAL",CollAsgnRejectReason_INVALID_TYPE_OF_COLLATERAL_get, CollAsgnRejectReason_INVALID_TYPE_OF_COLLATERAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnRejectReason_INSUFFICIENTCOLLATERAL",CollAsgnRejectReason_INSUFFICIENTCOLLATERAL_get, CollAsgnRejectReason_INSUFFICIENTCOLLATERAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnRejectReason_UNKNOWNORINVALIDINSTRUMENT",CollAsgnRejectReason_UNKNOWNORINVALIDINSTRUMENT_get, CollAsgnRejectReason_UNKNOWNORINVALIDINSTRUMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnRejectReason_EXCESSIVE_SUBSTITUTION",CollAsgnRejectReason_EXCESSIVE_SUBSTITUTION_get, CollAsgnRejectReason_EXCESSIVE_SUBSTITUTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnRejectReason_OTHER",CollAsgnRejectReason_OTHER_get, CollAsgnRejectReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnRejectReason_INSUFFICIENT_COLLATERAL",CollAsgnRejectReason_INSUFFICIENT_COLLATERAL_get, CollAsgnRejectReason_INSUFFICIENT_COLLATERAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnRejectReason_EXCESSIVESUBSTITUTION",CollAsgnRejectReason_EXCESSIVESUBSTITUTION_get, CollAsgnRejectReason_EXCESSIVESUBSTITUTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IndividualAllocType_SUB_ALLOCATE",IndividualAllocType_SUB_ALLOCATE_get, IndividualAllocType_SUB_ALLOCATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IndividualAllocType_THIRD_PARTY_ALLOCATION",IndividualAllocType_THIRD_PARTY_ALLOCATION_get, IndividualAllocType_THIRD_PARTY_ALLOCATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"GTBookingInst_ACCUMUNTILFILL",GTBookingInst_ACCUMUNTILFILL_get, GTBookingInst_ACCUMUNTILFILL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"GTBookingInst_ACCUMUNTILNOTIFY",GTBookingInst_ACCUMUNTILNOTIFY_get, GTBookingInst_ACCUMUNTILNOTIFY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"GTBookingInst_BOOK_OUT_ALL_TRADES_ON_DAY_OF_EXECUTION",GTBookingInst_BOOK_OUT_ALL_TRADES_ON_DAY_OF_EXECUTION_get, GTBookingInst_BOOK_OUT_ALL_TRADES_ON_DAY_OF_EXECUTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"GTBookingInst_ACCUMULATE_UNTIL_VERBALLY_NOTIFIED_OTHERWISE",GTBookingInst_ACCUMULATE_UNTIL_VERBALLY_NOTIFIED_OTHERWISE_get, GTBookingInst_ACCUMULATE_UNTIL_VERBALLY_NOTIFIED_OTHERWISE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"GTBookingInst_ACCUMULATE_EXECUTIONS_UNTIL_ORDER_IS_FILLED_OR_EXPIRES",GTBookingInst_ACCUMULATE_EXECUTIONS_UNTIL_ORDER_IS_FILLED_OR_EXPIRES_get, GTBookingInst_ACCUMULATE_EXECUTIONS_UNTIL_ORDER_IS_FILLED_OR_EXPIRES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"GTBookingInst_BOOKALL",GTBookingInst_BOOKALL_get, GTBookingInst_BOOKALL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"GTBookingInst_ACCUMULATE_UNTIL_VERBALLLY_NOTIFIED_OTHERWISE",GTBookingInst_ACCUMULATE_UNTIL_VERBALLLY_NOTIFIED_OTHERWISE_get, GTBookingInst_ACCUMULATE_UNTIL_VERBALLLY_NOTIFIED_OTHERWISE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"GTBookingInst_ACCUMULATE_EXECTUIONS_UNTIL_FORDER_IS_FILLED_OR_EXPIRES",GTBookingInst_ACCUMULATE_EXECTUIONS_UNTIL_FORDER_IS_FILLED_OR_EXPIRES_get, GTBookingInst_ACCUMULATE_EXECTUIONS_UNTIL_FORDER_IS_FILLED_OR_EXPIRES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PutOrCall_PUT",PutOrCall_PUT_get, PutOrCall_PUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PutOrCall_CALL",PutOrCall_CALL_get, PutOrCall_CALL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FundRenewWaiv_NO",FundRenewWaiv_NO_get, FundRenewWaiv_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FundRenewWaiv_YES",FundRenewWaiv_YES_get, FundRenewWaiv_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ForexReq_NO",ForexReq_NO_get, ForexReq_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ForexReq_YES",ForexReq_YES_get, ForexReq_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TickRuleType_TRADED_AS_A_SPREAD_LEG",TickRuleType_TRADED_AS_A_SPREAD_LEG_get, TickRuleType_TRADED_AS_A_SPREAD_LEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TickRuleType_REGULAR",TickRuleType_REGULAR_get, TickRuleType_REGULAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TickRuleType_VARIABLE",TickRuleType_VARIABLE_get, TickRuleType_VARIABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TickRuleType_SETTLED_AS_A_SPREAD_LEG",TickRuleType_SETTLED_AS_A_SPREAD_LEG_get, TickRuleType_SETTLED_AS_A_SPREAD_LEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TickRuleType_FIXED",TickRuleType_FIXED_get, TickRuleType_FIXED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionOffsetType_PRICE",DiscretionOffsetType_PRICE_get, DiscretionOffsetType_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionOffsetType_BASISPOINTS",DiscretionOffsetType_BASISPOINTS_get, DiscretionOffsetType_BASISPOINTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionOffsetType_PRICE_TIER",DiscretionOffsetType_PRICE_TIER_get, DiscretionOffsetType_PRICE_TIER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionOffsetType_TICKS",DiscretionOffsetType_TICKS_get, DiscretionOffsetType_TICKS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionOffsetType_PRICETIERLEVEL",DiscretionOffsetType_PRICETIERLEVEL_get, DiscretionOffsetType_PRICETIERLEVEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionOffsetType_BASIS_POINTS",DiscretionOffsetType_BASIS_POINTS_get, DiscretionOffsetType_BASIS_POINTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmTransType_REPLACE",ConfirmTransType_REPLACE_get, ConfirmTransType_REPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmTransType_NEW",ConfirmTransType_NEW_get, ConfirmTransType_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmTransType_CANCEL",ConfirmTransType_CANCEL_get, ConfirmTransType_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDSecSizeType_CUSTOMER",MDSecSizeType_CUSTOMER_get, MDSecSizeType_CUSTOMER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesEvent_CHANGE_OF_TRADING_STATUS",TradSesEvent_CHANGE_OF_TRADING_STATUS_get, TradSesEvent_CHANGE_OF_TRADING_STATUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesEvent_CHANGE_OF_TRADING_SESSION",TradSesEvent_CHANGE_OF_TRADING_SESSION_get, TradSesEvent_CHANGE_OF_TRADING_SESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesEvent_CHANGE_OF_TRADING_SUBSESSION",TradSesEvent_CHANGE_OF_TRADING_SUBSESSION_get, TradSesEvent_CHANGE_OF_TRADING_SUBSESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesEvent_TRADING_RESUMES",TradSesEvent_TRADING_RESUMES_get, TradSesEvent_TRADING_RESUMES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DlvyInstType_SECURITIES",DlvyInstType_SECURITIES_get, DlvyInstType_SECURITIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DlvyInstType_CASH",DlvyInstType_CASH_get, DlvyInstType_CASH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_IMPLIED_TRADE",TradeCondition_IMPLIED_TRADE_get, TradeCondition_IMPLIED_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_CASHMKT",TradeCondition_CASHMKT_get, TradeCondition_CASHMKT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_OPENING_PRICE",TradeCondition_OPENING_PRICE_get, TradeCondition_OPENING_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_PRIOR_REFERENCE_PRICE",TradeCondition_PRIOR_REFERENCE_PRICE_get, TradeCondition_PRIOR_REFERENCE_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_CANCEL_LAST_ETH",TradeCondition_CANCEL_LAST_ETH_get, TradeCondition_CANCEL_LAST_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_SELLER",TradeCondition_SELLER_get, TradeCondition_SELLER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_DISTRIBUTION",TradeCondition_DISTRIBUTION_get, TradeCondition_DISTRIBUTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_NEXT_DAY_TRADE",TradeCondition_NEXT_DAY_TRADE_get, TradeCondition_NEXT_DAY_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_STRADDLE_ETH",TradeCondition_STRADDLE_ETH_get, TradeCondition_STRADDLE_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_SPREAD",TradeCondition_SPREAD_get, TradeCondition_SPREAD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_OPENINGPRICE",TradeCondition_OPENINGPRICE_get, TradeCondition_OPENINGPRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_CROSSED_AO",TradeCondition_CROSSED_AO_get, TradeCondition_CROSSED_AO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_SOLD_LAST_SALE",TradeCondition_SOLD_LAST_SALE_get, TradeCondition_SOLD_LAST_SALE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_OPENED_SALE_ETH",TradeCondition_OPENED_SALE_ETH_get, TradeCondition_OPENED_SALE_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_REOPEN_ETH",TradeCondition_REOPEN_ETH_get, TradeCondition_REOPEN_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_SOLD_LAST_SALE_ETH",TradeCondition_SOLD_LAST_SALE_ETH_get, TradeCondition_SOLD_LAST_SALE_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_STOPPED_SOLD_LAST",TradeCondition_STOPPED_SOLD_LAST_get, TradeCondition_STOPPED_SOLD_LAST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_TRADES_RESULTING_FROM_INTERMARKET_SWEEP",TradeCondition_TRADES_RESULTING_FROM_INTERMARKET_SWEEP_get, TradeCondition_TRADES_RESULTING_FROM_INTERMARKET_SWEEP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_NEXTDAY_D",TradeCondition_NEXTDAY_D_get, TradeCondition_NEXTDAY_D_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_FORM_T",TradeCondition_FORM_T_get, TradeCondition_FORM_T_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_ADJUSTED",TradeCondition_ADJUSTED_get, TradeCondition_ADJUSTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_CANCEL_ETH",TradeCondition_CANCEL_ETH_get, TradeCondition_CANCEL_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_OUT_OF_SEQUENCE_ETH",TradeCondition_OUT_OF_SEQUENCE_ETH_get, TradeCondition_OUT_OF_SEQUENCE_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_RULE127",TradeCondition_RULE127_get, TradeCondition_RULE127_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_COMBO_ETH",TradeCondition_COMBO_ETH_get, TradeCondition_COMBO_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_CANCEL_ONLY_ETH",TradeCondition_CANCEL_ONLY_ETH_get, TradeCondition_CANCEL_ONLY_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_STRADDLE",TradeCondition_STRADDLE_get, TradeCondition_STRADDLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_OUTSIDE_SPREAD",TradeCondition_OUTSIDE_SPREAD_get, TradeCondition_OUTSIDE_SPREAD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_BUNCHED_SALE",TradeCondition_BUNCHED_SALE_get, TradeCondition_BUNCHED_SALE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_CANCEL_STOPPED",TradeCondition_CANCEL_STOPPED_get, TradeCondition_CANCEL_STOPPED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_LATE_OPEN_ETH",TradeCondition_LATE_OPEN_ETH_get, TradeCondition_LATE_OPEN_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_OPENING_REOPENING_TRADE_DETAIL",TradeCondition_OPENING_REOPENING_TRADE_DETAIL_get, TradeCondition_OPENING_REOPENING_TRADE_DETAIL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_CANCEL",TradeCondition_CANCEL_get, TradeCondition_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_COMBO",TradeCondition_COMBO_get, TradeCondition_COMBO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_OPENING",TradeCondition_OPENING_get, TradeCondition_OPENING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_ACQUISITION",TradeCondition_ACQUISITION_get, TradeCondition_ACQUISITION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_OPENED",TradeCondition_OPENED_get, TradeCondition_OPENED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_CANCEL_ONLY",TradeCondition_CANCEL_ONLY_get, TradeCondition_CANCEL_ONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_NEXT_DAY",TradeCondition_NEXT_DAY_get, TradeCondition_NEXT_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_BARGAIN_CONDITION",TradeCondition_BARGAIN_CONDITION_get, TradeCondition_BARGAIN_CONDITION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_STOPPED",TradeCondition_STOPPED_get, TradeCondition_STOPPED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_CONVERTED_PRICE_INDICATOR",TradeCondition_CONVERTED_PRICE_INDICATOR_get, TradeCondition_CONVERTED_PRICE_INDICATOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_OFFICIAL_CLOSING_PRICE",TradeCondition_OFFICIAL_CLOSING_PRICE_get, TradeCondition_OFFICIAL_CLOSING_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_ADJUSTED_ETH",TradeCondition_ADJUSTED_ETH_get, TradeCondition_ADJUSTED_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_AVGPX",TradeCondition_AVGPX_get, TradeCondition_AVGPX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_RULE_155_TRADE",TradeCondition_RULE_155_TRADE_get, TradeCondition_RULE_155_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_SOLDLAST",TradeCondition_SOLDLAST_get, TradeCondition_SOLDLAST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_NEXTDAY_J",TradeCondition_NEXTDAY_J_get, TradeCondition_NEXTDAY_J_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_AUTOMATIC_EXECUTION",TradeCondition_AUTOMATIC_EXECUTION_get, TradeCondition_AUTOMATIC_EXECUTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_CROSSED_X",TradeCondition_CROSSED_X_get, TradeCondition_CROSSED_X_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_AUTO_EXECUTION_ETH",TradeCondition_AUTO_EXECUTION_ETH_get, TradeCondition_AUTO_EXECUTION_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_MULTILEG_TO_MULTILEG_TRADE",TradeCondition_MULTILEG_TO_MULTILEG_TRADE_get, TradeCondition_MULTILEG_TO_MULTILEG_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_OFFICAL_CLOSING_PRICE",TradeCondition_OFFICAL_CLOSING_PRICE_get, TradeCondition_OFFICAL_CLOSING_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_FINAL_PRICE_OF_SESSION",TradeCondition_FINAL_PRICE_OF_SESSION_get, TradeCondition_FINAL_PRICE_OF_SESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_BASKET_INDEX",TradeCondition_BASKET_INDEX_get, TradeCondition_BASKET_INDEX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_TRADES_RESULTING_FROM_MANUAL_SLOW_QUOTE",TradeCondition_TRADES_RESULTING_FROM_MANUAL_SLOW_QUOTE_get, TradeCondition_TRADES_RESULTING_FROM_MANUAL_SLOW_QUOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_STOPPED_STOCK",TradeCondition_STOPPED_STOCK_get, TradeCondition_STOPPED_STOCK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_MULT_ASSET_CLASS_MULTILEG_TRADE",TradeCondition_MULT_ASSET_CLASS_MULTILEG_TRADE_get, TradeCondition_MULT_ASSET_CLASS_MULTILEG_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_STOPPED_ETH",TradeCondition_STOPPED_ETH_get, TradeCondition_STOPPED_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_REGULAR_ETH",TradeCondition_REGULAR_ETH_get, TradeCondition_REGULAR_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_CANCEL_OPEN",TradeCondition_CANCEL_OPEN_get, TradeCondition_CANCEL_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_CASH",TradeCondition_CASH_get, TradeCondition_CASH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_CASHTRADE",TradeCondition_CASHTRADE_get, TradeCondition_CASHTRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_RULE155",TradeCondition_RULE155_get, TradeCondition_RULE155_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_CANCEL_STOPPED_ETH",TradeCondition_CANCEL_STOPPED_ETH_get, TradeCondition_CANCEL_STOPPED_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_VOLUME_ONLY",TradeCondition_VOLUME_ONLY_get, TradeCondition_VOLUME_ONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_SPLIT_TRADE",TradeCondition_SPLIT_TRADE_get, TradeCondition_SPLIT_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_STOPPED_OUT_OF_SEQUENCE",TradeCondition_STOPPED_OUT_OF_SEQUENCE_get, TradeCondition_STOPPED_OUT_OF_SEQUENCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_CASH_TRADE",TradeCondition_CASH_TRADE_get, TradeCondition_CASH_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_IMBALANCE_MORE_BUYERS",TradeCondition_IMBALANCE_MORE_BUYERS_get, TradeCondition_IMBALANCE_MORE_BUYERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_BUNCHED",TradeCondition_BUNCHED_get, TradeCondition_BUNCHED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_INTRADAY",TradeCondition_INTRADAY_get, TradeCondition_INTRADAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_IMBALANCE_MORE_SELLERS",TradeCondition_IMBALANCE_MORE_SELLERS_get, TradeCondition_IMBALANCE_MORE_SELLERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_INTRADAY_TRADE_DETAIL",TradeCondition_INTRADAY_TRADE_DETAIL_get, TradeCondition_INTRADAY_TRADE_DETAIL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_RULE_127_TRADE",TradeCondition_RULE_127_TRADE_get, TradeCondition_RULE_127_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_IMBALANCEMOREBUYERS",TradeCondition_IMBALANCEMOREBUYERS_get, TradeCondition_IMBALANCEMOREBUYERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_REOPEN",TradeCondition_REOPEN_get, TradeCondition_REOPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_EX_PIT",TradeCondition_EX_PIT_get, TradeCondition_EX_PIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_CANCEL_LAST",TradeCondition_CANCEL_LAST_get, TradeCondition_CANCEL_LAST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_DIRECT_PLUS",TradeCondition_DIRECT_PLUS_get, TradeCondition_DIRECT_PLUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_IMBALANCEMORESELLERS",TradeCondition_IMBALANCEMORESELLERS_get, TradeCondition_IMBALANCEMORESELLERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_AVERAGE_PRICE_TRADE",TradeCondition_AVERAGE_PRICE_TRADE_get, TradeCondition_AVERAGE_PRICE_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_SOLD_LAST",TradeCondition_SOLD_LAST_get, TradeCondition_SOLD_LAST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_MARKETPLACE_ENTERED_TRADE",TradeCondition_MARKETPLACE_ENTERED_TRADE_get, TradeCondition_MARKETPLACE_ENTERED_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_SPREAD_ETH",TradeCondition_SPREAD_ETH_get, TradeCondition_SPREAD_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_CANCEL_OPEN_ETH",TradeCondition_CANCEL_OPEN_ETH_get, TradeCondition_CANCEL_OPEN_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_EXCHANGE_LAST",TradeCondition_EXCHANGE_LAST_get, TradeCondition_EXCHANGE_LAST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_FAST_MARKET",TradeCondition_FAST_MARKET_get, TradeCondition_FAST_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_BURST_BASKET",TradeCondition_BURST_BASKET_get, TradeCondition_BURST_BASKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_SOLD",TradeCondition_SOLD_get, TradeCondition_SOLD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceLimitType_PRICE",PriceLimitType_PRICE_get, PriceLimitType_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceLimitType_TICKS",PriceLimitType_TICKS_get, PriceLimitType_TICKS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceLimitType_PERCENTAGE",PriceLimitType_PERCENTAGE_get, PriceLimitType_PERCENTAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CommType_PER_SHARE",CommType_PER_SHARE_get, CommType_PER_SHARE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CommType_PCTWAIVEDCSHDISC",CommType_PCTWAIVEDCSHDISC_get, CommType_PCTWAIVEDCSHDISC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CommType_ABSOLUTE",CommType_ABSOLUTE_get, CommType_ABSOLUTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CommType_PCTWAIVEDENUNITS",CommType_PCTWAIVEDENUNITS_get, CommType_PCTWAIVEDENUNITS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CommType_PERBOND",CommType_PERBOND_get, CommType_PERBOND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CommType_PER_BOND",CommType_PER_BOND_get, CommType_PER_BOND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CommType_PERCENTAGE",CommType_PERCENTAGE_get, CommType_PERCENTAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CommType_PERCENTAGE_WAIVED_4",CommType_PERCENTAGE_WAIVED_4_get, CommType_PERCENTAGE_WAIVED_4_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CommType_POINTS_PER_BOND_OR_CONTRACT",CommType_POINTS_PER_BOND_OR_CONTRACT_get, CommType_POINTS_PER_BOND_OR_CONTRACT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CommType_PERCENTAGE_WAIVED_5",CommType_PERCENTAGE_WAIVED_5_get, CommType_PERCENTAGE_WAIVED_5_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CommType_PER_UNIT",CommType_PER_UNIT_get, CommType_PER_UNIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CommType_PERCENT",CommType_PERCENT_get, CommType_PERCENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CommType_4",CommType_4_get, CommType_4_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CommType_5",CommType_5_get, CommType_5_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_DISTRIB_INSTNS",RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_DISTRIB_INSTNS_get, RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_DISTRIB_INSTNS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALIDOWNERSHIPTYPE",RegistRejReasonCode_INVALIDOWNERSHIPTYPE_get, RegistRejReasonCode_INVALIDOWNERSHIPTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALIDREGDTLS",RegistRejReasonCode_INVALIDREGDTLS_get, RegistRejReasonCode_INVALIDREGDTLS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALIDMAILINGDTLS",RegistRejReasonCode_INVALIDMAILINGDTLS_get, RegistRejReasonCode_INVALIDMAILINGDTLS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DTLS",RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DTLS_get, RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DTLS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETAILS",RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETAILS_get, RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETAILS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INSTRUCTIONS",RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INSTRUCTIONS_get, RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INSTRUCTIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALIDINVESTORCOUNTRYOFRESIDENCE",RegistRejReasonCode_INVALIDINVESTORCOUNTRYOFRESIDENCE_get, RegistRejReasonCode_INVALIDINVESTORCOUNTRYOFRESIDENCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALIDCASHDISTRIBAGENTCODE",RegistRejReasonCode_INVALIDCASHDISTRIBAGENTCODE_get, RegistRejReasonCode_INVALIDCASHDISTRIBAGENTCODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_TAX_EXEMPT_TYPE",RegistRejReasonCode_INVALID_UNACCEPTABLE_TAX_EXEMPT_TYPE_get, RegistRejReasonCode_INVALID_UNACCEPTABLE_TAX_EXEMPT_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NAME",RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NAME_get, RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NAME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACEEPTABLE_INVESTOR_ID_SOURCE",RegistRejReasonCode_INVALID_UNACEEPTABLE_INVESTOR_ID_SOURCE_get, RegistRejReasonCode_INVALID_UNACEEPTABLE_INVESTOR_ID_SOURCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID_SOURCE",RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID_SOURCE_get, RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID_SOURCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALIDDATEOFBIRTH",RegistRejReasonCode_INVALIDDATEOFBIRTH_get, RegistRejReasonCode_INVALIDDATEOFBIRTH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALIDDISTRIBPAYMENTMETHOD",RegistRejReasonCode_INVALIDDISTRIBPAYMENTMETHOD_get, RegistRejReasonCode_INVALIDDISTRIBPAYMENTMETHOD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_DATE_OF_BIRTH",RegistRejReasonCode_INVALID_UNACCEPTABLE_DATE_OF_BIRTH_get, RegistRejReasonCode_INVALID_UNACCEPTABLE_DATE_OF_BIRTH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALIDNODISTRIBINSTNS",RegistRejReasonCode_INVALIDNODISTRIBINSTNS_get, RegistRejReasonCode_INVALIDNODISTRIBINSTNS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALIDCASHDISTRIBAGENTACCTNUM",RegistRejReasonCode_INVALIDCASHDISTRIBAGENTACCTNUM_get, RegistRejReasonCode_INVALIDCASHDISTRIBAGENTACCTNUM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALIDTAXEXEMPTTYPE",RegistRejReasonCode_INVALIDTAXEXEMPTTYPE_get, RegistRejReasonCode_INVALIDTAXEXEMPTTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALIDMAILINGINST",RegistRejReasonCode_INVALIDMAILINGINST_get, RegistRejReasonCode_INVALIDMAILINGINST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INST",RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INST_get, RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETLS",RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETLS_get, RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETLS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALIDACCOUNTTYPE",RegistRejReasonCode_INVALIDACCOUNTTYPE_get, RegistRejReasonCode_INVALIDACCOUNTTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PAYMENT_METHOD",RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PAYMENT_METHOD_get, RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PAYMENT_METHOD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_CODE",RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_CODE_get, RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_CODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DETAILS",RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DETAILS_get, RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DETAILS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALIDREGSEQNO",RegistRejReasonCode_INVALIDREGSEQNO_get, RegistRejReasonCode_INVALIDREGSEQNO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_OTHER",RegistRejReasonCode_OTHER_get, RegistRejReasonCode_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALIDDISTRIBPERCENTAGE",RegistRejReasonCode_INVALIDDISTRIBPERCENTAGE_get, RegistRejReasonCode_INVALIDDISTRIBPERCENTAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DTLS",RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DTLS_get, RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DTLS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_ACCOUNT_TYPE",RegistRejReasonCode_INVALID_UNACCEPTABLE_ACCOUNT_TYPE_get, RegistRejReasonCode_INVALID_UNACCEPTABLE_ACCOUNT_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DETAILS",RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DETAILS_get, RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DETAILS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALIDINVESTORIDSOURCE",RegistRejReasonCode_INVALIDINVESTORIDSOURCE_get, RegistRejReasonCode_INVALIDINVESTORIDSOURCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_COUNTRY_OF_RESIDENCE",RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_COUNTRY_OF_RESIDENCE_get, RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_COUNTRY_OF_RESIDENCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PERCENTAGE",RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PERCENTAGE_get, RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PERCENTAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALIDCASHDISTRIBAGENTACCTNAME",RegistRejReasonCode_INVALIDCASHDISTRIBAGENTACCTNAME_get, RegistRejReasonCode_INVALIDCASHDISTRIBAGENTACCTNAME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALIDNOREGDETLS",RegistRejReasonCode_INVALIDNOREGDETLS_get, RegistRejReasonCode_INVALIDNOREGDETLS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALIDINVESTORID",RegistRejReasonCode_INVALIDINVESTORID_get, RegistRejReasonCode_INVALIDINVESTORID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NUM",RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NUM_get, RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NUM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_SEQ_NO",RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_SEQ_NO_get, RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_SEQ_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID",RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID_get, RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_OWNERSHIP_TYPE",RegistRejReasonCode_INVALID_UNACCEPTABLE_OWNERSHIP_TYPE_get, RegistRejReasonCode_INVALID_UNACCEPTABLE_OWNERSHIP_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_NODISTRIBINSTNS",RegistRejReasonCode_INVALID_UNACCEPTABLE_NODISTRIBINSTNS_get, RegistRejReasonCode_INVALID_UNACCEPTABLE_NODISTRIBINSTNS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FinancialStatus_BANKRUPT",FinancialStatus_BANKRUPT_get, FinancialStatus_BANKRUPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FinancialStatus_PENDINGDELISTING",FinancialStatus_PENDINGDELISTING_get, FinancialStatus_PENDINGDELISTING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FinancialStatus_RESTRICTED",FinancialStatus_RESTRICTED_get, FinancialStatus_RESTRICTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FinancialStatus_PENDING_DELISTING",FinancialStatus_PENDING_DELISTING_get, FinancialStatus_PENDING_DELISTING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LastFragment_NO",LastFragment_NO_get, LastFragment_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LastFragment_YES",LastFragment_YES_get, LastFragment_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NotifyBrokerOfCredit_NO",NotifyBrokerOfCredit_NO_get, NotifyBrokerOfCredit_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NotifyBrokerOfCredit_YES",NotifyBrokerOfCredit_YES_get, NotifyBrokerOfCredit_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_REGISTERED_ADDRESS_12",PartySubIDType_REGISTERED_ADDRESS_12_get, PartySubIDType_REGISTERED_ADDRESS_12_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_CASH_ACCOUNT_NUMBER",PartySubIDType_CASH_ACCOUNT_NUMBER_get, PartySubIDType_CASH_ACCOUNT_NUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_FAX_NUMBER",PartySubIDType_FAX_NUMBER_get, PartySubIDType_FAX_NUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_CONTACTNAME",PartySubIDType_CONTACTNAME_get, PartySubIDType_CONTACTNAME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_RESERVEDANDAVAILABLEFORBILATERALLYAGREEDUPONUSERDEFINEDVALUES",PartySubIDType_RESERVEDANDAVAILABLEFORBILATERALLYAGREEDUPONUSERDEFINEDVALUES_get, PartySubIDType_RESERVEDANDAVAILABLEFORBILATERALLYAGREEDUPONUSERDEFINEDVALUES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_DEPARTMENT",PartySubIDType_DEPARTMENT_get, PartySubIDType_DEPARTMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_CONTACT_NAME",PartySubIDType_CONTACT_NAME_get, PartySubIDType_CONTACT_NAME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_TELEXNUMBER",PartySubIDType_TELEXNUMBER_get, PartySubIDType_TELEXNUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_PERSON",PartySubIDType_PERSON_get, PartySubIDType_PERSON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_FIRM",PartySubIDType_FIRM_get, PartySubIDType_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_CASH_ACCOUNT_NAME",PartySubIDType_CASH_ACCOUNT_NAME_get, PartySubIDType_CASH_ACCOUNT_NAME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_POSITION_ACCOUNT_TYPE",PartySubIDType_POSITION_ACCOUNT_TYPE_get, PartySubIDType_POSITION_ACCOUNT_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_POSTAL_ADDRESS",PartySubIDType_POSTAL_ADDRESS_get, PartySubIDType_POSTAL_ADDRESS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_SECURITY_LOCATE_ID",PartySubIDType_SECURITY_LOCATE_ID_get, PartySubIDType_SECURITY_LOCATE_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_POSTALADDRESS",PartySubIDType_POSTALADDRESS_get, PartySubIDType_POSTALADDRESS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_FUND_ACCOUNT_NAME",PartySubIDType_FUND_ACCOUNT_NAME_get, PartySubIDType_FUND_ACCOUNT_NAME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_PROFESSIONAL_CLIENT",PartySubIDType_PROFESSIONAL_CLIENT_get, PartySubIDType_PROFESSIONAL_CLIENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_LOCATION",PartySubIDType_LOCATION_get, PartySubIDType_LOCATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_FULLLEGALNAMEOFFIRM",PartySubIDType_FULLLEGALNAMEOFFIRM_get, PartySubIDType_FULLLEGALNAMEOFFIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_LOCATIONDESK",PartySubIDType_LOCATIONDESK_get, PartySubIDType_LOCATIONDESK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_REGISTEREDADDRESS_12",PartySubIDType_REGISTEREDADDRESS_12_get, PartySubIDType_REGISTEREDADDRESS_12_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_REGISTRATION_NUMBER",PartySubIDType_REGISTRATION_NUMBER_get, PartySubIDType_REGISTRATION_NUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_EMAILADDRESS",PartySubIDType_EMAILADDRESS_get, PartySubIDType_EMAILADDRESS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_SYSTEM",PartySubIDType_SYSTEM_get, PartySubIDType_SYSTEM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_SECURITIESACCOUNTNUMBER",PartySubIDType_SECURITIESACCOUNTNUMBER_get, PartySubIDType_SECURITIESACCOUNTNUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_REGULATORY_STATUS",PartySubIDType_REGULATORY_STATUS_get, PartySubIDType_REGULATORY_STATUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_CSD_PARTICIPANT_MEMBER_CODE",PartySubIDType_CSD_PARTICIPANT_MEMBER_CODE_get, PartySubIDType_CSD_PARTICIPANT_MEMBER_CODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_PHONENUMBER",PartySubIDType_PHONENUMBER_get, PartySubIDType_PHONENUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_CURRENCY_DELIVERY_IDENTIFIER",PartySubIDType_CURRENCY_DELIVERY_IDENTIFIER_get, PartySubIDType_CURRENCY_DELIVERY_IDENTIFIER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_REGISTRATION_NAME",PartySubIDType_REGISTRATION_NAME_get, PartySubIDType_REGISTRATION_NAME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_REGISTERED_ADDRESS_18",PartySubIDType_REGISTERED_ADDRESS_18_get, PartySubIDType_REGISTERED_ADDRESS_18_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_TELEX_NUMBER",PartySubIDType_TELEX_NUMBER_get, PartySubIDType_TELEX_NUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_EMAIL_ADDRESS",PartySubIDType_EMAIL_ADDRESS_get, PartySubIDType_EMAIL_ADDRESS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_FAXNUMBER",PartySubIDType_FAXNUMBER_get, PartySubIDType_FAXNUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_BIC",PartySubIDType_BIC_get, PartySubIDType_BIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_CASHACCOUNT",PartySubIDType_CASHACCOUNT_get, PartySubIDType_CASHACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_REGISTRATIONNUMBER",PartySubIDType_REGISTRATIONNUMBER_get, PartySubIDType_REGISTRATIONNUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_LOCATION_DESK",PartySubIDType_LOCATION_DESK_get, PartySubIDType_LOCATION_DESK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_APPLICATION",PartySubIDType_APPLICATION_get, PartySubIDType_APPLICATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_CASHACCOUNTNAME",PartySubIDType_CASHACCOUNTNAME_get, PartySubIDType_CASHACCOUNTNAME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_SECURITIES_ACCOUNT_NAME",PartySubIDType_SECURITIES_ACCOUNT_NAME_get, PartySubIDType_SECURITIES_ACCOUNT_NAME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_PHONE_NUMBER",PartySubIDType_PHONE_NUMBER_get, PartySubIDType_PHONE_NUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_SECURITIESACCOUNTNAME",PartySubIDType_SECURITIESACCOUNTNAME_get, PartySubIDType_SECURITIESACCOUNTNAME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_REGISTRATIONNAME",PartySubIDType_REGISTRATIONNAME_get, PartySubIDType_REGISTRATIONNAME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_ELIGIBLE_COUNTERPARTY",PartySubIDType_ELIGIBLE_COUNTERPARTY_get, PartySubIDType_ELIGIBLE_COUNTERPARTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_REGISTEREDADDRESS_18",PartySubIDType_REGISTEREDADDRESS_18_get, PartySubIDType_REGISTEREDADDRESS_18_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_SECURITIES_ACCOUNT_NUMBER",PartySubIDType_SECURITIES_ACCOUNT_NUMBER_get, PartySubIDType_SECURITIES_ACCOUNT_NUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_FULL_LEGAL_NAME_OF_FIRM",PartySubIDType_FULL_LEGAL_NAME_OF_FIRM_get, PartySubIDType_FULL_LEGAL_NAME_OF_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_MARKET_MAKER",PartySubIDType_MARKET_MAKER_get, PartySubIDType_MARKET_MAKER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_EXECUTION_VENUE",PartySubIDType_EXECUTION_VENUE_get, PartySubIDType_EXECUTION_VENUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_POSITIONACCOUNTTYPE",PartySubIDType_POSITIONACCOUNTTYPE_get, PartySubIDType_POSITIONACCOUNTTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_FUNDACCOUNTNAME",PartySubIDType_FUNDACCOUNTNAME_get, PartySubIDType_FUNDACCOUNTNAME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_CSDPARTICIPANTMEMBERCODE",PartySubIDType_CSDPARTICIPANTMEMBERCODE_get, PartySubIDType_CSDPARTICIPANTMEMBERCODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_REGULATORYSTATUS",PartySubIDType_REGULATORYSTATUS_get, PartySubIDType_REGULATORYSTATUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocNoOrdersType_EXPLICIT_LIST_PROVIDED",AllocNoOrdersType_EXPLICIT_LIST_PROVIDED_get, AllocNoOrdersType_EXPLICIT_LIST_PROVIDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocNoOrdersType_NOTSPECIFIED",AllocNoOrdersType_NOTSPECIFIED_get, AllocNoOrdersType_NOTSPECIFIED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocNoOrdersType_NOT_SPECIFIED",AllocNoOrdersType_NOT_SPECIFIED_get, AllocNoOrdersType_NOT_SPECIFIED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocNoOrdersType_EXPLICITLISTPROVIDED",AllocNoOrdersType_EXPLICITLISTPROVIDED_get, AllocNoOrdersType_EXPLICITLISTPROVIDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocLinkType_FX_SWAP",AllocLinkType_FX_SWAP_get, AllocLinkType_FX_SWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocLinkType_F_X_NETTING",AllocLinkType_F_X_NETTING_get, AllocLinkType_F_X_NETTING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocLinkType_FXNETTING",AllocLinkType_FXNETTING_get, AllocLinkType_FXNETTING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocLinkType_FX_NETTING",AllocLinkType_FX_NETTING_get, AllocLinkType_FX_NETTING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocLinkType_FXSWAP",AllocLinkType_FXSWAP_get, AllocLinkType_FXSWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocLinkType_F_X_SWAP",AllocLinkType_F_X_SWAP_get, AllocLinkType_F_X_SWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnderlyingSettlementType_T_PLUS_1",UnderlyingSettlementType_T_PLUS_1_get, UnderlyingSettlementType_T_PLUS_1_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnderlyingSettlementType_T_PLUS_3",UnderlyingSettlementType_T_PLUS_3_get, UnderlyingSettlementType_T_PLUS_3_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnderlyingSettlementType_T_PLUS_4",UnderlyingSettlementType_T_PLUS_4_get, UnderlyingSettlementType_T_PLUS_4_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DisplayMethod_NEW",DisplayMethod_NEW_get, DisplayMethod_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DisplayMethod_UNDISCLOSED",DisplayMethod_UNDISCLOSED_get, DisplayMethod_UNDISCLOSED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DisplayMethod_RANDOM",DisplayMethod_RANDOM_get, DisplayMethod_RANDOM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DisplayMethod_INITIAL",DisplayMethod_INITIAL_get, DisplayMethod_INITIAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollStatus_PARTIALLY_ASSIGNED",CollStatus_PARTIALLY_ASSIGNED_get, CollStatus_PARTIALLY_ASSIGNED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollStatus_ASSIGNEDACCEPTED",CollStatus_ASSIGNEDACCEPTED_get, CollStatus_ASSIGNEDACCEPTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollStatus_ASSIGNMENT_PROPOSED",CollStatus_ASSIGNMENT_PROPOSED_get, CollStatus_ASSIGNMENT_PROPOSED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollStatus_ASSIGNED",CollStatus_ASSIGNED_get, CollStatus_ASSIGNED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollStatus_CHALLENGED",CollStatus_CHALLENGED_get, CollStatus_CHALLENGED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollStatus_UNASSIGNED",CollStatus_UNASSIGNED_get, CollStatus_UNASSIGNED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollStatus_ASSIGNMENTPROPOSED",CollStatus_ASSIGNMENTPROPOSED_get, CollStatus_ASSIGNMENTPROPOSED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollStatus_PARTIALLYASSIGNED",CollStatus_PARTIALLYASSIGNED_get, CollStatus_PARTIALLYASSIGNED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SideValueInd_SIDEVALUE_2",SideValueInd_SIDEVALUE_2_get, SideValueInd_SIDEVALUE_2_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SideValueInd_SIDEVALUE1",SideValueInd_SIDEVALUE1_get, SideValueInd_SIDEVALUE1_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SideValueInd_SIDEVALUE2",SideValueInd_SIDEVALUE2_get, SideValueInd_SIDEVALUE2_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SideValueInd_SIDE_VALUE_1",SideValueInd_SIDE_VALUE_1_get, SideValueInd_SIDE_VALUE_1_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SideValueInd_SIDE_VALUE_2",SideValueInd_SIDE_VALUE_2_get, SideValueInd_SIDE_VALUE_2_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgDirection_RECEIVE",MsgDirection_RECEIVE_get, MsgDirection_RECEIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgDirection_SEND",MsgDirection_SEND_get, MsgDirection_SEND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDUpdateAction_DELETE",MDUpdateAction_DELETE_get, MDUpdateAction_DELETE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDUpdateAction_NEW",MDUpdateAction_NEW_get, MDUpdateAction_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDUpdateAction_DELETE_THRU",MDUpdateAction_DELETE_THRU_get, MDUpdateAction_DELETE_THRU_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDUpdateAction_DELETE_FROM",MDUpdateAction_DELETE_FROM_get, MDUpdateAction_DELETE_FROM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDUpdateAction_OVERLAY",MDUpdateAction_OVERLAY_get, MDUpdateAction_OVERLAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDUpdateAction_CHANGE",MDUpdateAction_CHANGE_get, MDUpdateAction_CHANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchStatus_ADVALERT",MatchStatus_ADVALERT_get, MatchStatus_ADVALERT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRED",MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRED_get, MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchStatus_COMPARED_MATCHED_OR_AFFIRMED",MatchStatus_COMPARED_MATCHED_OR_AFFIRMED_get, MatchStatus_COMPARED_MATCHED_OR_AFFIRMED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchStatus_ADVISORY_OR_ALERT",MatchStatus_ADVISORY_OR_ALERT_get, MatchStatus_ADVISORY_OR_ALERT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchStatus_UNCOMPUNMATUNAFF",MatchStatus_UNCOMPUNMATUNAFF_get, MatchStatus_UNCOMPUNMATUNAFF_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchStatus_COMPMATAFF",MatchStatus_COMPMATAFF_get, MatchStatus_COMPMATAFF_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRMED",MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRMED_get, MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRMED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RateSource_REUTERS",RateSource_REUTERS_get, RateSource_REUTERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RateSource_OTHER",RateSource_OTHER_get, RateSource_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RateSource_BLOOMBERG",RateSource_BLOOMBERG_get, RateSource_BLOOMBERG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RateSource_TELERATE",RateSource_TELERATE_get, RateSource_TELERATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocPositionEffect_CLOSE",AllocPositionEffect_CLOSE_get, AllocPositionEffect_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocPositionEffect_FIFO",AllocPositionEffect_FIFO_get, AllocPositionEffect_FIFO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocPositionEffect_OPEN",AllocPositionEffect_OPEN_get, AllocPositionEffect_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocPositionEffect_ROLLED",AllocPositionEffect_ROLLED_get, AllocPositionEffect_ROLLED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_US_EMPLOYER_OR_TAX_ID_NUMBER",PartyIDSource_US_EMPLOYER_OR_TAX_ID_NUMBER_get, PartyIDSource_US_EMPLOYER_OR_TAX_ID_NUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_PROPRIETARY",PartyIDSource_PROPRIETARY_get, PartyIDSource_PROPRIETARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_USEMPLOYERIDNUMBER",PartyIDSource_USEMPLOYERIDNUMBER_get, PartyIDSource_USEMPLOYERIDNUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_ACCPTMARKETPART",PartyIDSource_ACCPTMARKETPART_get, PartyIDSource_ACCPTMARKETPART_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_CSDPARTCODE",PartyIDSource_CSDPARTCODE_get, PartyIDSource_CSDPARTCODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_AUSTRALIAN_TAX_FILE_NUMBER",PartyIDSource_AUSTRALIAN_TAX_FILE_NUMBER_get, PartyIDSource_AUSTRALIAN_TAX_FILE_NUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_KOREANINVESTORID",PartyIDSource_KOREANINVESTORID_get, PartyIDSource_KOREANINVESTORID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER",PartyIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER_get, PartyIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_AUSTRALIAN_BUSINESS_NUMBER",PartyIDSource_AUSTRALIAN_BUSINESS_NUMBER_get, PartyIDSource_AUSTRALIAN_BUSINESS_NUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_US_EMPLOYER_IDENTIFICATION_NUMBER",PartyIDSource_US_EMPLOYER_IDENTIFICATION_NUMBER_get, PartyIDSource_US_EMPLOYER_IDENTIFICATION_NUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_AUSTRALIANTAXFILENUMBER",PartyIDSource_AUSTRALIANTAXFILENUMBER_get, PartyIDSource_AUSTRALIANTAXFILENUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_TAIWANESE_TRADING_ACCOUNT",PartyIDSource_TAIWANESE_TRADING_ACCOUNT_get, PartyIDSource_TAIWANESE_TRADING_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_TAIWANESE_TRADING_ACCT",PartyIDSource_TAIWANESE_TRADING_ACCT_get, PartyIDSource_TAIWANESE_TRADING_ACCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_CHINESEBSHARE",PartyIDSource_CHINESEBSHARE_get, PartyIDSource_CHINESEBSHARE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_AUSTRALIANBUSINESSNUMBER",PartyIDSource_AUSTRALIANBUSINESSNUMBER_get, PartyIDSource_AUSTRALIANBUSINESSNUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_MALAYSIAN_CENTRAL_DEPOSITORY",PartyIDSource_MALAYSIAN_CENTRAL_DEPOSITORY_get, PartyIDSource_MALAYSIAN_CENTRAL_DEPOSITORY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_US_SOCIAL_SECURITY_NUMBER",PartyIDSource_US_SOCIAL_SECURITY_NUMBER_get, PartyIDSource_US_SOCIAL_SECURITY_NUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_TAIWANESEQUALIFIED",PartyIDSource_TAIWANESEQUALIFIED_get, PartyIDSource_TAIWANESEQUALIFIED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_USSOCIALSECURITY",PartyIDSource_USSOCIALSECURITY_get, PartyIDSource_USSOCIALSECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_DIRECTEDDEFINEDISITC",PartyIDSource_DIRECTEDDEFINEDISITC_get, PartyIDSource_DIRECTEDDEFINEDISITC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_UK_NATIONAL_INSURANCE_OR_PENSION_NUMBER",PartyIDSource_UK_NATIONAL_INSURANCE_OR_PENSION_NUMBER_get, PartyIDSource_UK_NATIONAL_INSURANCE_OR_PENSION_NUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_CSD_PARTICIPANT_MEMBER_CODE",PartyIDSource_CSD_PARTICIPANT_MEMBER_CODE_get, 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",PartyIDSource_DIRECTED_BROKER_THREE_CHARACTER_ACRONYM_AS_DEFINED_IN_ISITC_ETC_BEST_PRACTICE_GUIDELINES_DOCUMENT_get, 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",PartyIDSource_TAIWANESE_QUALIFIED_FOREIGN_INVESTOR_ID_QFII_get, PartyIDSource_TAIWANESE_QUALIFIED_FOREIGN_INVESTOR_ID_QFII_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_SETTLEMENT_ENTITY_LOCATION",PartyIDSource_SETTLEMENT_ENTITY_LOCATION_get, PartyIDSource_SETTLEMENT_ENTITY_LOCATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_PROPRIETARY_CUSTOM_CODE",PartyIDSource_PROPRIETARY_CUSTOM_CODE_get, PartyIDSource_PROPRIETARY_CUSTOM_CODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_UKNATIONALINSPENNUMBER",PartyIDSource_UKNATIONALINSPENNUMBER_get, PartyIDSource_UKNATIONALINSPENNUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_BIC",PartyIDSource_BIC_get, PartyIDSource_BIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_CHINESE_INVESTOR_ID",PartyIDSource_CHINESE_INVESTOR_ID_get, PartyIDSource_CHINESE_INVESTOR_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_TAIWANESETRADINGACCT",PartyIDSource_TAIWANESETRADINGACCT_get, PartyIDSource_TAIWANESETRADINGACCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_MIC",PartyIDSource_MIC_get, PartyIDSource_MIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_KOREAN_INVESTOR_ID",PartyIDSource_KOREAN_INVESTOR_ID_get, PartyIDSource_KOREAN_INVESTOR_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_ISO_COUNTRY_CODE",PartyIDSource_ISO_COUNTRY_CODE_get, PartyIDSource_ISO_COUNTRY_CODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_TAIWANESE_QUALIFIED_FOREIGN_INVESTOR_ID_QFII_FID",PartyIDSource_TAIWANESE_QUALIFIED_FOREIGN_INVESTOR_ID_QFII_FID_get, PartyIDSource_TAIWANESE_QUALIFIED_FOREIGN_INVESTOR_ID_QFII_FID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_PROPCODE",PartyIDSource_PROPCODE_get, PartyIDSource_PROPCODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_ISOCODE",PartyIDSource_ISOCODE_get, PartyIDSource_ISOCODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_CHINESE_B_SHARE",PartyIDSource_CHINESE_B_SHARE_get, PartyIDSource_CHINESE_B_SHARE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_MCDNUMBER",PartyIDSource_MCDNUMBER_get, PartyIDSource_MCDNUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_SETTLENTLOC",PartyIDSource_SETTLENTLOC_get, PartyIDSource_SETTLENTLOC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExchangeForPhysical_NO",ExchangeForPhysical_NO_get, ExchangeForPhysical_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExchangeForPhysical_YES",ExchangeForPhysical_YES_get, ExchangeForPhysical_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingEvent_CHANGE_OF_SECURITY_TRADING_STATUS",SecurityTradingEvent_CHANGE_OF_SECURITY_TRADING_STATUS_get, SecurityTradingEvent_CHANGE_OF_SECURITY_TRADING_STATUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingEvent_CHANGE_OF_TRADING_SESSION",SecurityTradingEvent_CHANGE_OF_TRADING_SESSION_get, SecurityTradingEvent_CHANGE_OF_TRADING_SESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingEvent_CHANGE_OF_SECURITY_STATUS",SecurityTradingEvent_CHANGE_OF_SECURITY_STATUS_get, SecurityTradingEvent_CHANGE_OF_SECURITY_STATUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingEvent_PRICE_VOLATILITY_INTERRUPTION",SecurityTradingEvent_PRICE_VOLATILITY_INTERRUPTION_get, SecurityTradingEvent_PRICE_VOLATILITY_INTERRUPTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingEvent_CHANGE_OF_BOOK_TYPE",SecurityTradingEvent_CHANGE_OF_BOOK_TYPE_get, SecurityTradingEvent_CHANGE_OF_BOOK_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingEvent_CHANGE_OF_TRADING_SUBSESSION",SecurityTradingEvent_CHANGE_OF_TRADING_SUBSESSION_get, SecurityTradingEvent_CHANGE_OF_TRADING_SUBSESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingEvent_CHANGE_OF_MARKET_DEPTH",SecurityTradingEvent_CHANGE_OF_MARKET_DEPTH_get, SecurityTradingEvent_CHANGE_OF_MARKET_DEPTH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingEvent_TRADING_RESUMES",SecurityTradingEvent_TRADING_RESUMES_get, SecurityTradingEvent_TRADING_RESUMES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingEvent_ORDER_IMBALANCE_AUCTION_IS_EXTENDED",SecurityTradingEvent_ORDER_IMBALANCE_AUCTION_IS_EXTENDED_get, SecurityTradingEvent_ORDER_IMBALANCE_AUCTION_IS_EXTENDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAction_ADD",CollAction_ADD_get, CollAction_ADD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAction_REMOVE",CollAction_REMOVE_get, CollAction_REMOVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAction_RETAIN",CollAction_RETAIN_get, CollAction_RETAIN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PossDupFlag_NO",PossDupFlag_NO_get, PossDupFlag_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PossDupFlag_YES",PossDupFlag_YES_get, PossDupFlag_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListStatusType_ALL_DONE",ListStatusType_ALL_DONE_get, ListStatusType_ALL_DONE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListStatusType_TIMED",ListStatusType_TIMED_get, ListStatusType_TIMED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListStatusType_RESP",ListStatusType_RESP_get, ListStatusType_RESP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListStatusType_EXECSTARTED",ListStatusType_EXECSTARTED_get, ListStatusType_EXECSTARTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListStatusType_RESPONSE",ListStatusType_RESPONSE_get, ListStatusType_RESPONSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListStatusType_ALLDONE",ListStatusType_ALLDONE_get, ListStatusType_ALLDONE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListStatusType_ALERT",ListStatusType_ALERT_get, ListStatusType_ALERT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListStatusType_ACK",ListStatusType_ACK_get, ListStatusType_ACK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListStatusType_EXEC_STARTED",ListStatusType_EXEC_STARTED_get, ListStatusType_EXEC_STARTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListStatusType_EXECSTART",ListStatusType_EXECSTART_get, ListStatusType_EXECSTART_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"GapFillFlag_NO",GapFillFlag_NO_get, GapFillFlag_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"GapFillFlag_YES",GapFillFlag_YES_get, GapFillFlag_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeHandlingInstr_AUTOMATED_FLOOR_ORDER_ROUTING",TradeHandlingInstr_AUTOMATED_FLOOR_ORDER_ROUTING_get, TradeHandlingInstr_AUTOMATED_FLOOR_ORDER_ROUTING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeHandlingInstr_TWO_PARTY_REPORT",TradeHandlingInstr_TWO_PARTY_REPORT_get, TradeHandlingInstr_TWO_PARTY_REPORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeHandlingInstr_ONE_PARTY_REPORT_FOR_MATCHING",TradeHandlingInstr_ONE_PARTY_REPORT_FOR_MATCHING_get, TradeHandlingInstr_ONE_PARTY_REPORT_FOR_MATCHING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeHandlingInstr_TRADE_CONFIRMATION",TradeHandlingInstr_TRADE_CONFIRMATION_get, TradeHandlingInstr_TRADE_CONFIRMATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeHandlingInstr_ONE_PARTY_REPORT_FOR_PASS_THROUGH",TradeHandlingInstr_ONE_PARTY_REPORT_FOR_PASS_THROUGH_get, TradeHandlingInstr_ONE_PARTY_REPORT_FOR_PASS_THROUGH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeHandlingInstr_TWO_PARTY_REPORT_FOR_CLAIM",TradeHandlingInstr_TWO_PARTY_REPORT_FOR_CLAIM_get, TradeHandlingInstr_TWO_PARTY_REPORT_FOR_CLAIM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesMethod_TWOPARTY",TradSesMethod_TWOPARTY_get, TradSesMethod_TWOPARTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesMethod_ELECTRONIC",TradSesMethod_ELECTRONIC_get, TradSesMethod_ELECTRONIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesMethod_OPENOUTCRY",TradSesMethod_OPENOUTCRY_get, TradSesMethod_OPENOUTCRY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesMethod_TWO_PARTY",TradSesMethod_TWO_PARTY_get, TradSesMethod_TWO_PARTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesMethod_OPEN_OUTCRY",TradSesMethod_OPEN_OUTCRY_get, TradSesMethod_OPEN_OUTCRY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeType_AGENCY",TradeType_AGENCY_get, TradeType_AGENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeType_VWAP_GUARANTEE",TradeType_VWAP_GUARANTEE_get, TradeType_VWAP_GUARANTEE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeType_RISK_TRADE",TradeType_RISK_TRADE_get, TradeType_RISK_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeType_GUARANTEED_CLOSE",TradeType_GUARANTEED_CLOSE_get, TradeType_GUARANTEED_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventCondition_AND",ComplexEventCondition_AND_get, ComplexEventCondition_AND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventCondition_OR",ComplexEventCondition_OR_get, ComplexEventCondition_OR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BenchmarkCurveName_SONIA",BenchmarkCurveName_SONIA_get, BenchmarkCurveName_SONIA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BenchmarkCurveName_MUNIAAA",BenchmarkCurveName_MUNIAAA_get, BenchmarkCurveName_MUNIAAA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BenchmarkCurveName_LIBID",BenchmarkCurveName_LIBID_get, BenchmarkCurveName_LIBID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BenchmarkCurveName_PFANDBRIEFE",BenchmarkCurveName_PFANDBRIEFE_get, BenchmarkCurveName_PFANDBRIEFE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BenchmarkCurveName_EUREPO",BenchmarkCurveName_EUREPO_get, BenchmarkCurveName_EUREPO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BenchmarkCurveName_FUTURESWAP",BenchmarkCurveName_FUTURESWAP_get, BenchmarkCurveName_FUTURESWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BenchmarkCurveName_TREASURY",BenchmarkCurveName_TREASURY_get, BenchmarkCurveName_TREASURY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BenchmarkCurveName_OTHER",BenchmarkCurveName_OTHER_get, BenchmarkCurveName_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BenchmarkCurveName_EURIBOR",BenchmarkCurveName_EURIBOR_get, BenchmarkCurveName_EURIBOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BenchmarkCurveName_EONIA",BenchmarkCurveName_EONIA_get, BenchmarkCurveName_EONIA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BenchmarkCurveName_LIBOR",BenchmarkCurveName_LIBOR_get, BenchmarkCurveName_LIBOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BenchmarkCurveName_SWAP",BenchmarkCurveName_SWAP_get, BenchmarkCurveName_SWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CashMargin_MARGINCLOSE",CashMargin_MARGINCLOSE_get, CashMargin_MARGINCLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CashMargin_MARGINOPEN",CashMargin_MARGINOPEN_get, CashMargin_MARGINOPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CashMargin_MARGIN_CLOSE",CashMargin_MARGIN_CLOSE_get, CashMargin_MARGIN_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CashMargin_MARGIN_OPEN",CashMargin_MARGIN_OPEN_get, CashMargin_MARGIN_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CashMargin_CASH",CashMargin_CASH_get, CashMargin_CASH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlObligTransType_REPLACE",SettlObligTransType_REPLACE_get, SettlObligTransType_REPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlObligTransType_NEW",SettlObligTransType_NEW_get, SettlObligTransType_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlObligTransType_RESTATE",SettlObligTransType_RESTATE_get, SettlObligTransType_RESTATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlObligTransType_CANCEL",SettlObligTransType_CANCEL_get, SettlObligTransType_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_PEGGED",DeskOrderHandlingInst_PEGGED_get, DeskOrderHandlingInst_PEGGED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_MARKET_ON_OPEN",DeskOrderHandlingInst_MARKET_ON_OPEN_get, DeskOrderHandlingInst_MARKET_ON_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_SCALE",DeskOrderHandlingInst_SCALE_get, DeskOrderHandlingInst_SCALE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_FILL_OR_KILL",DeskOrderHandlingInst_FILL_OR_KILL_get, DeskOrderHandlingInst_FILL_OR_KILL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_ALL_OR_NONE",DeskOrderHandlingInst_ALL_OR_NONE_get, DeskOrderHandlingInst_ALL_OR_NONE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_NOT_HELD",DeskOrderHandlingInst_NOT_HELD_get, DeskOrderHandlingInst_NOT_HELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_DIRECTED_ORDER",DeskOrderHandlingInst_DIRECTED_ORDER_get, DeskOrderHandlingInst_DIRECTED_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_STOP_STOCK_TRANSACTION",DeskOrderHandlingInst_STOP_STOCK_TRANSACTION_get, DeskOrderHandlingInst_STOP_STOCK_TRANSACTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_OVER_THE_DAY",DeskOrderHandlingInst_OVER_THE_DAY_get, DeskOrderHandlingInst_OVER_THE_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_ADD_ON_ORDER",DeskOrderHandlingInst_ADD_ON_ORDER_get, DeskOrderHandlingInst_ADD_ON_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_MARKET_AT_CLOSE",DeskOrderHandlingInst_MARKET_AT_CLOSE_get, DeskOrderHandlingInst_MARKET_AT_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_LIMIT_ON_OPEN",DeskOrderHandlingInst_LIMIT_ON_OPEN_get, DeskOrderHandlingInst_LIMIT_ON_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_CASH_NOT_HELD",DeskOrderHandlingInst_CASH_NOT_HELD_get, DeskOrderHandlingInst_CASH_NOT_HELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_MARKET_ON_CLOSE",DeskOrderHandlingInst_MARKET_ON_CLOSE_get, DeskOrderHandlingInst_MARKET_ON_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_TIME_ORDER",DeskOrderHandlingInst_TIME_ORDER_get, DeskOrderHandlingInst_TIME_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_LIMIT_ON_CLOSE",DeskOrderHandlingInst_LIMIT_ON_CLOSE_get, DeskOrderHandlingInst_LIMIT_ON_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_IMMEDIATE_OR_CANCEL",DeskOrderHandlingInst_IMMEDIATE_OR_CANCEL_get, DeskOrderHandlingInst_IMMEDIATE_OR_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_TRAILING_STOP",DeskOrderHandlingInst_TRAILING_STOP_get, DeskOrderHandlingInst_TRAILING_STOP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_WORK",DeskOrderHandlingInst_WORK_get, DeskOrderHandlingInst_WORK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_RESERVE_SIZE_ORDER",DeskOrderHandlingInst_RESERVE_SIZE_ORDER_get, DeskOrderHandlingInst_RESERVE_SIZE_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_MINIMUM_QUANTITY",DeskOrderHandlingInst_MINIMUM_QUANTITY_get, DeskOrderHandlingInst_MINIMUM_QUANTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_MARKET_AT_OPEN",DeskOrderHandlingInst_MARKET_AT_OPEN_get, DeskOrderHandlingInst_MARKET_AT_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_IMBALANCE_ONLY",DeskOrderHandlingInst_IMBALANCE_ONLY_get, DeskOrderHandlingInst_IMBALANCE_ONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION",DeskOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION_get, DeskOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosTransType_DO_NOT_EXERCISE",PosTransType_DO_NOT_EXERCISE_get, PosTransType_DO_NOT_EXERCISE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosTransType_POSITION_CHANGE_SUBMISSION_MARGIN_DISPOSITION",PosTransType_POSITION_CHANGE_SUBMISSION_MARGIN_DISPOSITION_get, PosTransType_POSITION_CHANGE_SUBMISSION_MARGIN_DISPOSITION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosTransType_DONOTEXERCISE",PosTransType_DONOTEXERCISE_get, PosTransType_DONOTEXERCISE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosTransType_LARGE_TRADER_SUBMISSION",PosTransType_LARGE_TRADER_SUBMISSION_get, PosTransType_LARGE_TRADER_SUBMISSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosTransType_POSITIONCHANGESUBMISSIONMARGINDISPOSITION",PosTransType_POSITIONCHANGESUBMISSIONMARGINDISPOSITION_get, PosTransType_POSITIONCHANGESUBMISSIONMARGINDISPOSITION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosTransType_POSITIONADJUSTMENT",PosTransType_POSITIONADJUSTMENT_get, PosTransType_POSITIONADJUSTMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosTransType_EXERCISE",PosTransType_EXERCISE_get, PosTransType_EXERCISE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosTransType_POSITION_ADJUSTMENT",PosTransType_POSITION_ADJUSTMENT_get, PosTransType_POSITION_ADJUSTMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosTransType_PLEDGE",PosTransType_PLEDGE_get, PosTransType_PLEDGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Seniority_SUBORDINATED",Seniority_SUBORDINATED_get, Seniority_SUBORDINATED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Seniority_SENIOR_SECURED",Seniority_SENIOR_SECURED_get, Seniority_SENIOR_SECURED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Seniority_SENIOR",Seniority_SENIOR_get, Seniority_SENIOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlCurrFxRateCalc_DIVIDE",SettlCurrFxRateCalc_DIVIDE_get, SettlCurrFxRateCalc_DIVIDE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlCurrFxRateCalc_MULTIPLY",SettlCurrFxRateCalc_MULTIPLY_get, SettlCurrFxRateCalc_MULTIPLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosMaintStatus_ACCEPTED_WITH_WARNINGS",PosMaintStatus_ACCEPTED_WITH_WARNINGS_get, PosMaintStatus_ACCEPTED_WITH_WARNINGS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosMaintStatus_COMPLETED",PosMaintStatus_COMPLETED_get, PosMaintStatus_COMPLETED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosMaintStatus_ACCEPTEDWITHWARNINGS",PosMaintStatus_ACCEPTEDWITHWARNINGS_get, PosMaintStatus_ACCEPTEDWITHWARNINGS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosMaintStatus_COMPLETEDWITHWARNINGS",PosMaintStatus_COMPLETEDWITHWARNINGS_get, PosMaintStatus_COMPLETEDWITHWARNINGS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosMaintStatus_REJECTED",PosMaintStatus_REJECTED_get, PosMaintStatus_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosMaintStatus_ACCEPTED",PosMaintStatus_ACCEPTED_get, PosMaintStatus_ACCEPTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosMaintStatus_COMPLETED_WITH_WARNINGS",PosMaintStatus_COMPLETED_WITH_WARNINGS_get, PosMaintStatus_COMPLETED_WITH_WARNINGS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Benchmark_6_MO_LIBOR",Benchmark_6_MO_LIBOR_get, Benchmark_6_MO_LIBOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Benchmark_OLD_5",Benchmark_OLD_5_get, Benchmark_OLD_5_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Benchmark_OLD_30",Benchmark_OLD_30_get, Benchmark_OLD_30_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Benchmark_30YR",Benchmark_30YR_get, Benchmark_30YR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Benchmark_5YR",Benchmark_5YR_get, Benchmark_5YR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Benchmark_3_MO_LIBOR",Benchmark_3_MO_LIBOR_get, Benchmark_3_MO_LIBOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Benchmark_OLD_10",Benchmark_OLD_10_get, Benchmark_OLD_10_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Benchmark_6MOLIBOR",Benchmark_6MOLIBOR_get, Benchmark_6MOLIBOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Benchmark_10YR",Benchmark_10YR_get, Benchmark_10YR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Benchmark_CURVE",Benchmark_CURVE_get, Benchmark_CURVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Benchmark_30_YR",Benchmark_30_YR_get, Benchmark_30_YR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Benchmark_10_YR",Benchmark_10_YR_get, Benchmark_10_YR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Benchmark_5_YR",Benchmark_5_YR_get, Benchmark_5_YR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Benchmark_OLD30",Benchmark_OLD30_get, Benchmark_OLD30_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Benchmark_OLD5",Benchmark_OLD5_get, Benchmark_OLD5_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Benchmark_OLD10",Benchmark_OLD10_get, Benchmark_OLD10_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Benchmark_3MOLIBOR",Benchmark_3MOLIBOR_get, Benchmark_3MOLIBOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MaturityMonthYearFormat_YEARMONTHWEEK",MaturityMonthYearFormat_YEARMONTHWEEK_get, MaturityMonthYearFormat_YEARMONTHWEEK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MaturityMonthYearFormat_YEARMONTHDAY",MaturityMonthYearFormat_YEARMONTHDAY_get, MaturityMonthYearFormat_YEARMONTHDAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MaturityMonthYearFormat_YEARMONTH_ONLY",MaturityMonthYearFormat_YEARMONTH_ONLY_get, MaturityMonthYearFormat_YEARMONTH_ONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LegalConfirm_NO",LegalConfirm_NO_get, LegalConfirm_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LegalConfirm_YES",LegalConfirm_YES_get, LegalConfirm_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplReportType_REPORTS_THAT_THE_LAST_MESSAGE_HAS_BEEN_SENT_FOR_THE_APPLIDS_REFER_TO_REFAPPLLASTSEQNUM",ApplReportType_REPORTS_THAT_THE_LAST_MESSAGE_HAS_BEEN_SENT_FOR_THE_APPLIDS_REFER_TO_REFAPPLLASTSEQNUM_get, 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",ApplReportType_APPLICATION_MESSAGE_RE_SEND_COMPLETED_get, ApplReportType_APPLICATION_MESSAGE_RE_SEND_COMPLETED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplReportType_RESET_APPLSEQNUM_TO_NEW_VALUE_SPECIFIED_IN_APPLNEWSEQNUM",ApplReportType_RESET_APPLSEQNUM_TO_NEW_VALUE_SPECIFIED_IN_APPLNEWSEQNUM_get, ApplReportType_RESET_APPLSEQNUM_TO_NEW_VALUE_SPECIFIED_IN_APPLNEWSEQNUM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplReportType_HEARTBEAT_MESSAGE_INDICATING_THAT_APPLICATION_IDENTIFIED_BY_REFAPPLID",ApplReportType_HEARTBEAT_MESSAGE_INDICATING_THAT_APPLICATION_IDENTIFIED_BY_REFAPPLID_get, ApplReportType_HEARTBEAT_MESSAGE_INDICATING_THAT_APPLICATION_IDENTIFIED_BY_REFAPPLID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ReportToExch_NO",ReportToExch_NO_get, ReportToExch_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ReportToExch_YES",ReportToExch_YES_get, ReportToExch_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_INCORRECT_ALLOCATED_QUANTITY",AllocRejCode_INCORRECT_ALLOCATED_QUANTITY_get, AllocRejCode_INCORRECT_ALLOCATED_QUANTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_UNKNOWNACCT",AllocRejCode_UNKNOWNACCT_get, AllocRejCode_UNKNOWNACCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_INCORRECTAVGPRC",AllocRejCode_INCORRECTAVGPRC_get, AllocRejCode_INCORRECTAVGPRC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_UNKNOWN_ORDERID",AllocRejCode_UNKNOWN_ORDERID_get, AllocRejCode_UNKNOWN_ORDERID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_WAREHOUSEREQUESTREJECTED",AllocRejCode_WAREHOUSEREQUESTREJECTED_get, AllocRejCode_WAREHOUSEREQUESTREJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_UNKNOWNORSTALEEXECID",AllocRejCode_UNKNOWNORSTALEEXECID_get, AllocRejCode_UNKNOWNORSTALEEXECID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_WAREHOUSE_REQUEST_REJECTED",AllocRejCode_WAREHOUSE_REQUEST_REJECTED_get, AllocRejCode_WAREHOUSE_REQUEST_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_INCORRECT_AVERAGEG_PRICE",AllocRejCode_INCORRECT_AVERAGEG_PRICE_get, AllocRejCode_INCORRECT_AVERAGEG_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_MISMATCHEDDATA",AllocRejCode_MISMATCHEDDATA_get, AllocRejCode_MISMATCHEDDATA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_INCORRECTBRKMNC",AllocRejCode_INCORRECTBRKMNC_get, AllocRejCode_INCORRECTBRKMNC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_UNKNOWNLISTID",AllocRejCode_UNKNOWNLISTID_get, AllocRejCode_UNKNOWNLISTID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_OTHER_99",AllocRejCode_OTHER_99_get, AllocRejCode_OTHER_99_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_INCORRECTALLOCATEDQUANTITY",AllocRejCode_INCORRECTALLOCATEDQUANTITY_get, AllocRejCode_INCORRECTALLOCATEDQUANTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_UNKNOWN_LISTID",AllocRejCode_UNKNOWN_LISTID_get, AllocRejCode_UNKNOWN_LISTID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_INCORRECT_QUANTITY",AllocRejCode_INCORRECT_QUANTITY_get, AllocRejCode_INCORRECT_QUANTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_INCORRECT_AVERAGE_PRICE",AllocRejCode_INCORRECT_AVERAGE_PRICE_get, AllocRejCode_INCORRECT_AVERAGE_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_UNKNOWN_ACCOUNT",AllocRejCode_UNKNOWN_ACCOUNT_get, AllocRejCode_UNKNOWN_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_UNKNOWN_OR_STALE_EXECID",AllocRejCode_UNKNOWN_OR_STALE_EXECID_get, AllocRejCode_UNKNOWN_OR_STALE_EXECID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_OTHER",AllocRejCode_OTHER_get, AllocRejCode_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_OTHER_7",AllocRejCode_OTHER_7_get, AllocRejCode_OTHER_7_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_UNKNOWN_CLORDID",AllocRejCode_UNKNOWN_CLORDID_get, AllocRejCode_UNKNOWN_CLORDID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_INCORRECTQTY",AllocRejCode_INCORRECTQTY_get, AllocRejCode_INCORRECTQTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_COMMDIFF",AllocRejCode_COMMDIFF_get, AllocRejCode_COMMDIFF_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_CALCULATIONDIFFERENCE",AllocRejCode_CALCULATIONDIFFERENCE_get, AllocRejCode_CALCULATIONDIFFERENCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_UNKNOWNCLORDID",AllocRejCode_UNKNOWNCLORDID_get, AllocRejCode_UNKNOWNCLORDID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_UNKNOWNORDID",AllocRejCode_UNKNOWNORDID_get, AllocRejCode_UNKNOWNORDID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_MISMATCHED_DATA",AllocRejCode_MISMATCHED_DATA_get, AllocRejCode_MISMATCHED_DATA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_CALCULATION_DIFFERENCE",AllocRejCode_CALCULATION_DIFFERENCE_get, AllocRejCode_CALCULATION_DIFFERENCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_COMMISSION_DIFFERENCE",AllocRejCode_COMMISSION_DIFFERENCE_get, AllocRejCode_COMMISSION_DIFFERENCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_UNKNOWN_EXECUTING_BROKER_MNEMONIC",AllocRejCode_UNKNOWN_EXECUTING_BROKER_MNEMONIC_get, AllocRejCode_UNKNOWN_EXECUTING_BROKER_MNEMONIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RefOrdIDReason_GTC_FROM_PREVIOUS_DAY",RefOrdIDReason_GTC_FROM_PREVIOUS_DAY_get, RefOrdIDReason_GTC_FROM_PREVIOUS_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RefOrdIDReason_PARTIAL_FILL_REMAINING",RefOrdIDReason_PARTIAL_FILL_REMAINING_get, RefOrdIDReason_PARTIAL_FILL_REMAINING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RefOrdIDReason_ORDER_CHANGED",RefOrdIDReason_ORDER_CHANGED_get, RefOrdIDReason_ORDER_CHANGED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RefOrderIDSource_SECONDARYORDERID",RefOrderIDSource_SECONDARYORDERID_get, RefOrderIDSource_SECONDARYORDERID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RefOrderIDSource_ORDERID",RefOrderIDSource_ORDERID_get, RefOrderIDSource_ORDERID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RefOrderIDSource_MDENTRYID",RefOrderIDSource_MDENTRYID_get, RefOrderIDSource_MDENTRYID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RefOrderIDSource_ORIGINAL_ORDER_ID",RefOrderIDSource_ORIGINAL_ORDER_ID_get, RefOrderIDSource_ORIGINAL_ORDER_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RefOrderIDSource_MENTRYID",RefOrderIDSource_MENTRYID_get, RefOrderIDSource_MENTRYID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RefOrderIDSource_QUOTEENTRYID",RefOrderIDSource_QUOTEENTRYID_get, RefOrderIDSource_QUOTEENTRYID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RefOrderIDSource_QUOTENTRYID",RefOrderIDSource_QUOTENTRYID_get, RefOrderIDSource_QUOTENTRYID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RefOrderIDSource_ORDEID",RefOrderIDSource_ORDEID_get, RefOrderIDSource_ORDEID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RefOrderIDSource_SECONDARYORDEID",RefOrderIDSource_SECONDARYORDEID_get, RefOrderIDSource_SECONDARYORDEID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LastCapacity_A",LastCapacity_A_get, LastCapacity_A_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LastCapacity_XP",LastCapacity_XP_get, LastCapacity_XP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LastCapacity_CROSS_AS_PRINCIPAL",LastCapacity_CROSS_AS_PRINCIPAL_get, LastCapacity_CROSS_AS_PRINCIPAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LastCapacity_PRINCIPAL",LastCapacity_PRINCIPAL_get, LastCapacity_PRINCIPAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LastCapacity_P",LastCapacity_P_get, LastCapacity_P_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LastCapacity_CROSS_AS_AGENT",LastCapacity_CROSS_AS_AGENT_get, LastCapacity_CROSS_AS_AGENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LastCapacity_AGENT",LastCapacity_AGENT_get, LastCapacity_AGENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LastCapacity_XA",LastCapacity_XA_get, LastCapacity_XA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_INSTRUMENT_STRIKE_PRICE",InstrAttribType_INSTRUMENT_STRIKE_PRICE_get, InstrAttribType_INSTRUMENT_STRIKE_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_IN_DEFAULT",InstrAttribType_IN_DEFAULT_get, InstrAttribType_IN_DEFAULT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_COUPONPERIOD",InstrAttribType_COUPONPERIOD_get, InstrAttribType_COUPONPERIOD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_ORIGINAL_ISSUE_DISCOUNT",InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_get, InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_PRE_REFUNDED",InstrAttribType_PRE_REFUNDED_get, InstrAttribType_PRE_REFUNDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_SUBJECT_TO_ALTERNATIVE_MINIMUM_TAX",InstrAttribType_SUBJECT_TO_ALTERNATIVE_MINIMUM_TAX_get, InstrAttribType_SUBJECT_TO_ALTERNATIVE_MINIMUM_TAX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_CALLABLEPUTTABLE",InstrAttribType_CALLABLEPUTTABLE_get, InstrAttribType_CALLABLEPUTTABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_WHEN_AND_IF_ISSUED",InstrAttribType_WHEN_AND_IF_ISSUED_get, InstrAttribType_WHEN_AND_IF_ISSUED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_STEPPEDCOUPON",InstrAttribType_STEPPEDCOUPON_get, InstrAttribType_STEPPEDCOUPON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_UNRATED",InstrAttribType_UNRATED_get, InstrAttribType_UNRATED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_CALLABLE_WITHOUT_NOTICE_BY_MAIL_TO_HOLDER_UNLESS_REGISTERED",InstrAttribType_CALLABLE_WITHOUT_NOTICE_BY_MAIL_TO_HOLDER_UNLESS_REGISTERED_get, InstrAttribType_CALLABLE_WITHOUT_NOTICE_BY_MAIL_TO_HOLDER_UNLESS_REGISTERED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_STEPPED_COUPON",InstrAttribType_STEPPED_COUPON_get, InstrAttribType_STEPPED_COUPON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_TEXT",InstrAttribType_TEXT_get, InstrAttribType_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_ORIGINALISSUEDISCOUNTPRICE",InstrAttribType_ORIGINALISSUEDISCOUNTPRICE_get, InstrAttribType_ORIGINALISSUEDISCOUNTPRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_ESCROWEDTOREDEMPTIONDATE",InstrAttribType_ESCROWEDTOREDEMPTIONDATE_get, InstrAttribType_ESCROWEDTOREDEMPTIONDATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_INSTRUMENT_DENOMINATOR",InstrAttribType_INSTRUMENT_DENOMINATOR_get, InstrAttribType_INSTRUMENT_DENOMINATOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_ESCROWED_TO_REDEMPTION_DATE",InstrAttribType_ESCROWED_TO_REDEMPTION_DATE_get, InstrAttribType_ESCROWED_TO_REDEMPTION_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_INTEREST_BEARING",InstrAttribType_INTEREST_BEARING_get, InstrAttribType_INTEREST_BEARING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_TAXABLE",InstrAttribType_TAXABLE_get, InstrAttribType_TAXABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_CALLABLE_PUTTABLE",InstrAttribType_CALLABLE_PUTTABLE_get, InstrAttribType_CALLABLE_PUTTABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_CALLABLE_BELOW_MATURITY_VALUE",InstrAttribType_CALLABLE_BELOW_MATURITY_VALUE_get, InstrAttribType_CALLABLE_BELOW_MATURITY_VALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_COUPON_PERIOD",InstrAttribType_COUPON_PERIOD_get, InstrAttribType_COUPON_PERIOD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_LESSFEEFORPUT",InstrAttribType_LESSFEEFORPUT_get, InstrAttribType_LESSFEEFORPUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_INTERESTBEARING",InstrAttribType_INTERESTBEARING_get, InstrAttribType_INTERESTBEARING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_PREREFUNDED",InstrAttribType_PREREFUNDED_get, InstrAttribType_PREREFUNDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_INSTRUMENT_PRICE_PRECISION",InstrAttribType_INSTRUMENT_PRICE_PRECISION_get, InstrAttribType_INSTRUMENT_PRICE_PRECISION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_TRADEABLE_INDICATOR",InstrAttribType_TRADEABLE_INDICATOR_get, InstrAttribType_TRADEABLE_INDICATOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_PRICE_SUPPLY_PRICE_IN_THE_INSTRATTRIBVALUE",InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_PRICE_SUPPLY_PRICE_IN_THE_INSTRATTRIBVALUE_get, InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_PRICE_SUPPLY_PRICE_IN_THE_INSTRATTRIBVALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_VARIABLE_RATE",InstrAttribType_VARIABLE_RATE_get, InstrAttribType_VARIABLE_RATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_WHENISSUED",InstrAttribType_WHENISSUED_get, InstrAttribType_WHENISSUED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_ZEROCOUPON",InstrAttribType_ZEROCOUPON_get, InstrAttribType_ZEROCOUPON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_SUBJECTTOALTERNATIVEMINIMUMTAX",InstrAttribType_SUBJECTTOALTERNATIVEMINIMUMTAX_get, InstrAttribType_SUBJECTTOALTERNATIVEMINIMUMTAX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_ESCROWEDTOMATURITY",InstrAttribType_ESCROWEDTOMATURITY_get, InstrAttribType_ESCROWEDTOMATURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_FLAT",InstrAttribType_FLAT_get, InstrAttribType_FLAT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_TRADE_TYPE_ELIGIBILITY_DETAILS_FOR_SECURITY",InstrAttribType_TRADE_TYPE_ELIGIBILITY_DETAILS_FOR_SECURITY_get, InstrAttribType_TRADE_TYPE_ELIGIBILITY_DETAILS_FOR_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_INSTRUMENT_NUMERATOR",InstrAttribType_INSTRUMENT_NUMERATOR_get, InstrAttribType_INSTRUMENT_NUMERATOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_ESCROWED_TO_MATURITY",InstrAttribType_ESCROWED_TO_MATURITY_get, InstrAttribType_ESCROWED_TO_MATURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_LESS_FEE_FOR_PUT",InstrAttribType_LESS_FEE_FOR_PUT_get, InstrAttribType_LESS_FEE_FOR_PUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_TEXT_SUPPLY_THE_TEXT_OF_THE_ATTRIBUTE_OR_DISCLAIMER_IN_THE_INSTRATTRIBVALUE",InstrAttribType_TEXT_SUPPLY_THE_TEXT_OF_THE_ATTRIBUTE_OR_DISCLAIMER_IN_THE_INSTRATTRIBVALUE_get, InstrAttribType_TEXT_SUPPLY_THE_TEXT_OF_THE_ATTRIBUTE_OR_DISCLAIMER_IN_THE_INSTRATTRIBVALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_CALLABLEWITHOUTNOTICEBYMAILTOHOLDERUNLESSREGISTERED",InstrAttribType_CALLABLEWITHOUTNOTICEBYMAILTOHOLDERUNLESSREGISTERED_get, InstrAttribType_CALLABLEWITHOUTNOTICEBYMAILTOHOLDERUNLESSREGISTERED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_INDEXED",InstrAttribType_INDEXED_get, InstrAttribType_INDEXED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_INDEFAULT",InstrAttribType_INDEFAULT_get, InstrAttribType_INDEFAULT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_ZERO_COUPON",InstrAttribType_ZERO_COUPON_get, InstrAttribType_ZERO_COUPON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_NOPERIODICPAYMENTS",InstrAttribType_NOPERIODICPAYMENTS_get, InstrAttribType_NOPERIODICPAYMENTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_CALLABLEBELOWMATURITYVALUE",InstrAttribType_CALLABLEBELOWMATURITYVALUE_get, InstrAttribType_CALLABLEBELOWMATURITYVALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_ORIGINALISSUEDISCOUNT",InstrAttribType_ORIGINALISSUEDISCOUNT_get, InstrAttribType_ORIGINALISSUEDISCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_PRICE_TICK_RULES_FOR_SECURITY",InstrAttribType_PRICE_TICK_RULES_FOR_SECURITY_get, InstrAttribType_PRICE_TICK_RULES_FOR_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_NO_PERIODIC_PAYMENTS",InstrAttribType_NO_PERIODIC_PAYMENTS_get, InstrAttribType_NO_PERIODIC_PAYMENTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_VARIABLERATE",InstrAttribType_VARIABLERATE_get, InstrAttribType_VARIABLERATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Product_FINANCING",Product_FINANCING_get, Product_FINANCING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Product_COMMODITY",Product_COMMODITY_get, Product_COMMODITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Product_EQUITY",Product_EQUITY_get, Product_EQUITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Product_CORPORATE",Product_CORPORATE_get, Product_CORPORATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Product_AGENCY",Product_AGENCY_get, Product_AGENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Product_OTHER",Product_OTHER_get, Product_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Product_MONEYMARKET",Product_MONEYMARKET_get, Product_MONEYMARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Product_MORTGAGE",Product_MORTGAGE_get, Product_MORTGAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Product_CURRENCY",Product_CURRENCY_get, Product_CURRENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Product_INDEX",Product_INDEX_get, Product_INDEX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Product_MUNICIPAL",Product_MUNICIPAL_get, Product_MUNICIPAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Product_LOAN",Product_LOAN_get, Product_LOAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Product_GOVERNMENT",Product_GOVERNMENT_get, Product_GOVERNMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_NOMKTIMB",SecurityTradingStatus_NOMKTIMB_get, SecurityTradingStatus_NOMKTIMB_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_NOOPEN",SecurityTradingStatus_NOOPEN_get, SecurityTradingStatus_NOOPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_FAST_MARKET",SecurityTradingStatus_FAST_MARKET_get, SecurityTradingStatus_FAST_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_NO_OPEN_NO_RESUME",SecurityTradingStatus_NO_OPEN_NO_RESUME_get, SecurityTradingStatus_NO_OPEN_NO_RESUME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_TRADING_HALT",SecurityTradingStatus_TRADING_HALT_get, SecurityTradingStatus_TRADING_HALT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_NOT_AVAILABLE_FOR_TRADING",SecurityTradingStatus_NOT_AVAILABLE_FOR_TRADING_get, SecurityTradingStatus_NOT_AVAILABLE_FOR_TRADING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_11",SecurityTradingStatus_11_get, SecurityTradingStatus_11_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_NO_OPEN",SecurityTradingStatus_NO_OPEN_get, SecurityTradingStatus_NO_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_NOTTRADED",SecurityTradingStatus_NOTTRADED_get, SecurityTradingStatus_NOTTRADED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_FASTMARKET",SecurityTradingStatus_FASTMARKET_get, SecurityTradingStatus_FASTMARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_MKTBALSELL",SecurityTradingStatus_MKTBALSELL_get, SecurityTradingStatus_MKTBALSELL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_NEWPXIND",SecurityTradingStatus_NEWPXIND_get, SecurityTradingStatus_NEWPXIND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_TRDDISTIME",SecurityTradingStatus_TRDDISTIME_get, SecurityTradingStatus_TRDDISTIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_PXIND",SecurityTradingStatus_PXIND_get, SecurityTradingStatus_PXIND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_CROSS",SecurityTradingStatus_CROSS_get, SecurityTradingStatus_CROSS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_OPENINGROTATION",SecurityTradingStatus_OPENINGROTATION_get, SecurityTradingStatus_OPENINGROTATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_TRDRNGIND",SecurityTradingStatus_TRDRNGIND_get, SecurityTradingStatus_TRDRNGIND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_RESUME",SecurityTradingStatus_RESUME_get, SecurityTradingStatus_RESUME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_TRADE_DISSEMINATION_TIME",SecurityTradingStatus_TRADE_DISSEMINATION_TIME_get, SecurityTradingStatus_TRADE_DISSEMINATION_TIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_NO_MARKET_ON_CLOSE_IMBALANCE",SecurityTradingStatus_NO_MARKET_ON_CLOSE_IMBALANCE_get, SecurityTradingStatus_NO_MARKET_ON_CLOSE_IMBALANCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_POST_CLOSE",SecurityTradingStatus_POST_CLOSE_get, SecurityTradingStatus_POST_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_OPENDELAY",SecurityTradingStatus_OPENDELAY_get, SecurityTradingStatus_OPENDELAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_READY",SecurityTradingStatus_READY_get, SecurityTradingStatus_READY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_BUY",SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_BUY_get, SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_BUY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_NOTAVAIL",SecurityTradingStatus_NOTAVAIL_get, SecurityTradingStatus_NOTAVAIL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_MARKET_IMBALANCE_SELL",SecurityTradingStatus_MARKET_IMBALANCE_SELL_get, SecurityTradingStatus_MARKET_IMBALANCE_SELL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_OPENING_DELAY",SecurityTradingStatus_OPENING_DELAY_get, SecurityTradingStatus_OPENING_DELAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_MKTONCLSIMBSELL",SecurityTradingStatus_MKTONCLSIMBSELL_get, SecurityTradingStatus_MKTONCLSIMBSELL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_NOT_TRADED_ON_THIS_MARKET",SecurityTradingStatus_NOT_TRADED_ON_THIS_MARKET_get, SecurityTradingStatus_NOT_TRADED_ON_THIS_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_ITS_PRE_OPENING",SecurityTradingStatus_ITS_PRE_OPENING_get, SecurityTradingStatus_ITS_PRE_OPENING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_PRE_CROSS",SecurityTradingStatus_PRE_CROSS_get, SecurityTradingStatus_PRE_CROSS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_NA",SecurityTradingStatus_NA_get, SecurityTradingStatus_NA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_NOMKTONCLSIMB",SecurityTradingStatus_NOMKTONCLSIMB_get, SecurityTradingStatus_NOMKTONCLSIMB_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_PRE_OPEN",SecurityTradingStatus_PRE_OPEN_get, SecurityTradingStatus_PRE_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_MARKET_IMBALANCE_BUY",SecurityTradingStatus_MARKET_IMBALANCE_BUY_get, SecurityTradingStatus_MARKET_IMBALANCE_BUY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_TRADING_RANGE_INDICATION",SecurityTradingStatus_TRADING_RANGE_INDICATION_get, SecurityTradingStatus_TRADING_RANGE_INDICATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_READY_TO_TRADE",SecurityTradingStatus_READY_TO_TRADE_get, SecurityTradingStatus_READY_TO_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_NEW_PRICE_INDICATION",SecurityTradingStatus_NEW_PRICE_INDICATION_get, SecurityTradingStatus_NEW_PRICE_INDICATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_ITSPREOPN",SecurityTradingStatus_ITSPREOPN_get, SecurityTradingStatus_ITSPREOPN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_TRDHALT",SecurityTradingStatus_TRDHALT_get, SecurityTradingStatus_TRDHALT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_MKTONCLSIMBBUY",SecurityTradingStatus_MKTONCLSIMBBUY_get, SecurityTradingStatus_MKTONCLSIMBBUY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_OPENING_ROTATION",SecurityTradingStatus_OPENING_ROTATION_get, SecurityTradingStatus_OPENING_ROTATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_PRICE_INDICATION",SecurityTradingStatus_PRICE_INDICATION_get, SecurityTradingStatus_PRICE_INDICATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_UNKNOWN_OR_INVALID",SecurityTradingStatus_UNKNOWN_OR_INVALID_get, SecurityTradingStatus_UNKNOWN_OR_INVALID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_SELL",SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_SELL_get, SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_SELL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_UNKNOWN",SecurityTradingStatus_UNKNOWN_get, SecurityTradingStatus_UNKNOWN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_MKTIMBBUY",SecurityTradingStatus_MKTIMBBUY_get, SecurityTradingStatus_MKTIMBBUY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_NO_MARKET_IMBALANCE",SecurityTradingStatus_NO_MARKET_IMBALANCE_get, SecurityTradingStatus_NO_MARKET_IMBALANCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_PRGINDEXARBOTHMEM",Rule80A_PRGINDEXARBOTHMEM_get, Rule80A_PRGINDEXARBOTHMEM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_A_NON_MEMBER_COMPETING_MARKET_MAKER",Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_A_NON_MEMBER_COMPETING_MARKET_MAKER_get, Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_A_NON_MEMBER_COMPETING_MARKET_MAKER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_SPECIALIST_TRADES",Rule80A_SPECIALIST_TRADES_get, Rule80A_SPECIALIST_TRADES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_INDIVIDUAL_CUSTOMER",Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_INDIVIDUAL_CUSTOMER_get, Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_INDIVIDUAL_CUSTOMER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_MEMBER_FIRM_ORG",Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_MEMBER_FIRM_ORG_get, Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_MEMBER_FIRM_ORG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_SHTEXTRANI",Rule80A_SHTEXTRANI_get, Rule80A_SHTEXTRANI_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_SHTEXTRANMEMWT",Rule80A_SHTEXTRANMEMWT_get, Rule80A_SHTEXTRANMEMWT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_SHORT_EXEMPT_TRANSACTION_F",Rule80A_SHORT_EXEMPT_TRANSACTION_F_get, Rule80A_SHORT_EXEMPT_TRANSACTION_F_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_COMPETING_DEALER_TRADES_O",Rule80A_COMPETING_DEALER_TRADES_O_get, Rule80A_COMPETING_DEALER_TRADES_O_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_INDIVIDUAL_CUSTOMER",Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_INDIVIDUAL_CUSTOMER_get, Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_INDIVIDUAL_CUSTOMER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_AGENCY_ALGORITHMIC_PROGRAM_TRADING",Rule80A_AGENCY_ALGORITHMIC_PROGRAM_TRADING_get, Rule80A_AGENCY_ALGORITHMIC_PROGRAM_TRADING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_SHTEXTRANMEM",Rule80A_SHTEXTRANMEM_get, Rule80A_SHTEXTRANMEM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_PRGINDEXARBOTHAGN",Rule80A_PRGINDEXARBOTHAGN_get, Rule80A_PRGINDEXARBOTHAGN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_PRGNONINDEXARBINV",Rule80A_PRGNONINDEXARBINV_get, Rule80A_PRGNONINDEXARBINV_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_SHORT_EXEMPT_TRANSACTION_H",Rule80A_SHORT_EXEMPT_TRANSACTION_H_get, Rule80A_SHORT_EXEMPT_TRANSACTION_H_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_PRINCIPAL",Rule80A_PRINCIPAL_get, Rule80A_PRINCIPAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_AGENCY_INDEX_ARBITRAGE",Rule80A_AGENCY_INDEX_ARBITRAGE_get, Rule80A_AGENCY_INDEX_ARBITRAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_A_NON_MEMBER_COMPTING_MARKET_MAKER",Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_A_NON_MEMBER_COMPTING_MARKET_MAKER_get, Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_A_NON_MEMBER_COMPTING_MARKET_MAKER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_SHTEXTRANA",Rule80A_SHTEXTRANA_get, Rule80A_SHTEXTRANA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_SHTEXTRANW",Rule80A_SHTEXTRANW_get, Rule80A_SHTEXTRANW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_PRGINDEXARBINV",Rule80A_PRGINDEXARBINV_get, Rule80A_PRGINDEXARBINV_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_COMPETING_DEALER_TRADES_R",Rule80A_COMPETING_DEALER_TRADES_R_get, Rule80A_COMPETING_DEALER_TRADES_R_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_INDIVIDUAL_INVESTOR_SINGLE_ORDER",Rule80A_INDIVIDUAL_INVESTOR_SINGLE_ORDER_get, Rule80A_INDIVIDUAL_INVESTOR_SINGLE_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_PROPRIETARY_NON_ALGORITHMIC_PROGRAM_TRADE",Rule80A_PROPRIETARY_NON_ALGORITHMIC_PROGRAM_TRADE_get, Rule80A_PROPRIETARY_NON_ALGORITHMIC_PROGRAM_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_AGENT_FOR_OTHER_MEMBER_NON_ALGORITHMIC_PROGRAM_TRADE",Rule80A_AGENT_FOR_OTHER_MEMBER_NON_ALGORITHMIC_PROGRAM_TRADE_get, Rule80A_AGENT_FOR_OTHER_MEMBER_NON_ALGORITHMIC_PROGRAM_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_ALLOTHERAGN",Rule80A_ALLOTHERAGN_get, Rule80A_ALLOTHERAGN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_PRGNONINDEXARBOTHAGN",Rule80A_PRGNONINDEXARBOTHAGN_get, Rule80A_PRGNONINDEXARBOTHAGN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_PROPRIETARY_TRANSACTIONS_FOR_COMPETING_MARKET_MAKER_THAT_IS_AFFILIATED_WITH_THE_CLEARING_MEMBER",Rule80A_PROPRIETARY_TRANSACTIONS_FOR_COMPETING_MARKET_MAKER_THAT_IS_AFFILIATED_WITH_THE_CLEARING_MEMBER_get, 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",Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_NOT_AFFILIATED_WITH_THE_FIRM_CLEARING_THE_TRADE_get, Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_NOT_AFFILIATED_WITH_THE_FIRM_CLEARING_THE_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_AGENCYSINGLE",Rule80A_AGENCYSINGLE_get, Rule80A_AGENCYSINGLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_COMPETING_DEALER_TRADES_T",Rule80A_COMPETING_DEALER_TRADES_T_get, Rule80A_COMPETING_DEALER_TRADES_T_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_OTHER_MEMBER",Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_OTHER_MEMBER_get, Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_OTHER_MEMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_PROPRIETARY_ALGORITHMIC_PROGRAM_TRADING",Rule80A_PROPRIETARY_ALGORITHMIC_PROGRAM_TRADING_get, Rule80A_PROPRIETARY_ALGORITHMIC_PROGRAM_TRADING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_AGENCY_NON_ALGORITHMIC_PROGRAM_TRADE",Rule80A_AGENCY_NON_ALGORITHMIC_PROGRAM_TRADE_get, Rule80A_AGENCY_NON_ALGORITHMIC_PROGRAM_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_PRGNONINDEXARBMEM",Rule80A_PRGNONINDEXARBMEM_get, Rule80A_PRGNONINDEXARBMEM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_PRGNONINDEXARBOTHMEM",Rule80A_PRGNONINDEXARBOTHMEM_get, Rule80A_PRGNONINDEXARBOTHMEM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_NON_MEMBER_COMPETING_MARKET_MAKER",Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_NON_MEMBER_COMPETING_MARKET_MAKER_get, 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",Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_OTHER_AGENCY_get, Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_OTHER_AGENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_ALL_OTHER_ORDERS_AS_AGENT_FOR_OTHER_MEMBER",Rule80A_ALL_OTHER_ORDERS_AS_AGENT_FOR_OTHER_MEMBER_get, 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",Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_MEMBER_FIRM_ORG_get, Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_MEMBER_FIRM_ORG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_PRGINDEXARBMEM",Rule80A_PRGINDEXARBMEM_get, Rule80A_PRGINDEXARBMEM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_INVINESTOR",Rule80A_INVINESTOR_get, Rule80A_INVINESTOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_PRINCIPAL",Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_PRINCIPAL_get, Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_PRINCIPAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_SHORT_EXEMPT_TRANSACTION_B",Rule80A_SHORT_EXEMPT_TRANSACTION_B_get, 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",Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_AFFILIATED_WITH_THE_FIRM_CLEARING_THE_TRADE_get, 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",Rule80A_AGENCY_SINGLE_ORDER_get, Rule80A_AGENCY_SINGLE_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_AFFLIATED_WITH_THE_FIRM_CLEARING_THE_TRADE",Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_AFFLIATED_WITH_THE_FIRM_CLEARING_THE_TRADE_get, Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_AFFLIATED_WITH_THE_FIRM_CLEARING_THE_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_COMPETINGDEALER",Rule80A_COMPETINGDEALER_get, Rule80A_COMPETINGDEALER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_COMPDEALER1",Rule80A_COMPDEALER1_get, Rule80A_COMPDEALER1_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_SHTEXTRANNONMEM",Rule80A_SHTEXTRANNONMEM_get, Rule80A_SHTEXTRANNONMEM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_AN_UNAFFILIATED_MEMBERS_COMPETING_MARKET_MAKER",Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_AN_UNAFFILIATED_MEMBERS_COMPETING_MARKET_MAKER_get, Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_AN_UNAFFILIATED_MEMBERS_COMPETING_MARKET_MAKER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_REGISTERED_EQUITY_MARKET_MAKER_TRADES",Rule80A_REGISTERED_EQUITY_MARKET_MAKER_TRADES_get, Rule80A_REGISTERED_EQUITY_MARKET_MAKER_TRADES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_MARKETMAKER",Rule80A_MARKETMAKER_get, Rule80A_MARKETMAKER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_SPECIALIST",Rule80A_SPECIALIST_get, Rule80A_SPECIALIST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_COMPDEALER2",Rule80A_COMPDEALER2_get, Rule80A_COMPDEALER2_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_AGENCY",Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_AGENCY_get, Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_AGENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_MEMBER",Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_MEMBER_get, Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_MEMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_MERGER_REORGANIZATION",CorporateAction_MERGER_REORGANIZATION_get, CorporateAction_MERGER_REORGANIZATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_SYMBOL_CONVERSION",CorporateAction_SYMBOL_CONVERSION_get, CorporateAction_SYMBOL_CONVERSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_NEW",CorporateAction_NEW_get, CorporateAction_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_SUCCESSION_EVENT",CorporateAction_SUCCESSION_EVENT_get, CorporateAction_SUCCESSION_EVENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_STOCK_DIVIDEND",CorporateAction_STOCK_DIVIDEND_get, CorporateAction_STOCK_DIVIDEND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_REVERSE_STOCK_SPLIT",CorporateAction_REVERSE_STOCK_SPLIT_get, CorporateAction_REVERSE_STOCK_SPLIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_POSITION_CONSOLIDATION",CorporateAction_POSITION_CONSOLIDATION_get, CorporateAction_POSITION_CONSOLIDATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_SPINOFF",CorporateAction_SPINOFF_get, CorporateAction_SPINOFF_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_EXDIVIDEND",CorporateAction_EXDIVIDEND_get, CorporateAction_EXDIVIDEND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_EX_INTEREST",CorporateAction_EX_INTEREST_get, CorporateAction_EX_INTEREST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_LIQUIDATION_REORGANIZATION",CorporateAction_LIQUIDATION_REORGANIZATION_get, CorporateAction_LIQUIDATION_REORGANIZATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_CASH_DIVIDEND",CorporateAction_CASH_DIVIDEND_get, CorporateAction_CASH_DIVIDEND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_STANDARD_INTEGER_STOCK_SPLIT",CorporateAction_STANDARD_INTEGER_STOCK_SPLIT_get, CorporateAction_STANDARD_INTEGER_STOCK_SPLIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_RIGHTS_OFFERING",CorporateAction_RIGHTS_OFFERING_get, CorporateAction_RIGHTS_OFFERING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_SHAREHOLDER_MEETING",CorporateAction_SHAREHOLDER_MEETING_get, CorporateAction_SHAREHOLDER_MEETING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_WARRANT",CorporateAction_WARRANT_get, CorporateAction_WARRANT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_EXDIST",CorporateAction_EXDIST_get, CorporateAction_EXDIST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_EX_RIGHTS",CorporateAction_EX_RIGHTS_get, CorporateAction_EX_RIGHTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_EX_DISTRIBUTION",CorporateAction_EX_DISTRIBUTION_get, CorporateAction_EX_DISTRIBUTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_EX_DIVIDEND",CorporateAction_EX_DIVIDEND_get, CorporateAction_EX_DIVIDEND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_TENDER_OFFER",CorporateAction_TENDER_OFFER_get, CorporateAction_TENDER_OFFER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_SPECIAL_ACTION",CorporateAction_SPECIAL_ACTION_get, CorporateAction_SPECIAL_ACTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_EXINTEREST",CorporateAction_EXINTEREST_get, CorporateAction_EXINTEREST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_NON_INTEGER_STOCK_SPLIT",CorporateAction_NON_INTEGER_STOCK_SPLIT_get, CorporateAction_NON_INTEGER_STOCK_SPLIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_CUSIP",CorporateAction_CUSIP_get, CorporateAction_CUSIP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_LEAP_ROLLOVER",CorporateAction_LEAP_ROLLOVER_get, CorporateAction_LEAP_ROLLOVER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_EXRIGHTS",CorporateAction_EXRIGHTS_get, CorporateAction_EXRIGHTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TerminationType_TERM",TerminationType_TERM_get, TerminationType_TERM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TerminationType_FLEXIBLE",TerminationType_FLEXIBLE_get, TerminationType_FLEXIBLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TerminationType_OPEN",TerminationType_OPEN_get, TerminationType_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TerminationType_OVERNIGHT",TerminationType_OVERNIGHT_get, TerminationType_OVERNIGHT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosMaintAction_REPLACE",PosMaintAction_REPLACE_get, PosMaintAction_REPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosMaintAction_NEW",PosMaintAction_NEW_get, PosMaintAction_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosMaintAction_REVERSE",PosMaintAction_REVERSE_get, PosMaintAction_REVERSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosMaintAction_CANCEL",PosMaintAction_CANCEL_get, PosMaintAction_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventPriceTimeType_SPECIFIED_DATE_TIME",ComplexEventPriceTimeType_SPECIFIED_DATE_TIME_get, ComplexEventPriceTimeType_SPECIFIED_DATE_TIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventPriceTimeType_EXPIRATION",ComplexEventPriceTimeType_EXPIRATION_get, ComplexEventPriceTimeType_EXPIRATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventPriceTimeType_IMMEDIATE",ComplexEventPriceTimeType_IMMEDIATE_get, ComplexEventPriceTimeType_IMMEDIATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnderlyingFXRateCalc_DIVIDE",UnderlyingFXRateCalc_DIVIDE_get, UnderlyingFXRateCalc_DIVIDE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnderlyingFXRateCalc_MULTIPLY",UnderlyingFXRateCalc_MULTIPLY_get, UnderlyingFXRateCalc_MULTIPLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OddLot_NO",OddLot_NO_get, OddLot_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OddLot_YES",OddLot_YES_get, OddLot_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BookingUnit_AGGREGATE_EXECUTIONS_FOR_THIS_SYMBOL_SIDE_AND_SETTLEMENT_DATE",BookingUnit_AGGREGATE_EXECUTIONS_FOR_THIS_SYMBOL_SIDE_AND_SETTLEMENT_DATE_get, 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",BookingUnit_AGGREGATE_PARTIAL_EXECUTIONS_ON_THIS_ORDER_AND_BOOK_ONE_TRADE_PER_ORDER_get, 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",BookingUnit_EACH_PARTIAL_EXECUTION_IS_A_BOOKABLE_UNIT_get, BookingUnit_EACH_PARTIAL_EXECUTION_IS_A_BOOKABLE_UNIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocStatus_REJECTED_BY_INTERMEDIARY",AllocStatus_REJECTED_BY_INTERMEDIARY_get, AllocStatus_REJECTED_BY_INTERMEDIARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocStatus_ACCEPTEDSUCCESSFULLYPROCESSED",AllocStatus_ACCEPTEDSUCCESSFULLYPROCESSED_get, AllocStatus_ACCEPTEDSUCCESSFULLYPROCESSED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocStatus_ACCOUNTLEVELREJECT",AllocStatus_ACCOUNTLEVELREJECT_get, AllocStatus_ACCOUNTLEVELREJECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocStatus_BLOCK_LEVEL_REJECT",AllocStatus_BLOCK_LEVEL_REJECT_get, AllocStatus_BLOCK_LEVEL_REJECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocStatus_ACCOUNT_LEVEL_REJECT",AllocStatus_ACCOUNT_LEVEL_REJECT_get, AllocStatus_ACCOUNT_LEVEL_REJECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocStatus_INCOMPLETE",AllocStatus_INCOMPLETE_get, AllocStatus_INCOMPLETE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocStatus_ALLOCATION_PENDING",AllocStatus_ALLOCATION_PENDING_get, AllocStatus_ALLOCATION_PENDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocStatus_BLOCKLEVELREJECT",AllocStatus_BLOCKLEVELREJECT_get, AllocStatus_BLOCKLEVELREJECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocStatus_REJECTEDBYINTERMEDIARY",AllocStatus_REJECTEDBYINTERMEDIARY_get, AllocStatus_REJECTEDBYINTERMEDIARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocStatus_RECEIVEDRECEIVEDNOTYETPROCESSED",AllocStatus_RECEIVEDRECEIVEDNOTYETPROCESSED_get, AllocStatus_RECEIVEDRECEIVEDNOTYETPROCESSED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocStatus_REVERSED",AllocStatus_REVERSED_get, AllocStatus_REVERSED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocStatus_RECEIVED",AllocStatus_RECEIVED_get, AllocStatus_RECEIVED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocStatus_PARTIAL_ACCEPT",AllocStatus_PARTIAL_ACCEPT_get, AllocStatus_PARTIAL_ACCEPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocStatus_REJECTED",AllocStatus_REJECTED_get, AllocStatus_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocStatus_ACCEPTED",AllocStatus_ACCEPTED_get, AllocStatus_ACCEPTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IncTaxInd_NET",IncTaxInd_NET_get, IncTaxInd_NET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IncTaxInd_GROSS",IncTaxInd_GROSS_get, IncTaxInd_GROSS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyListResponseType_RETURN_ONLY_PARTY_INFORMATION",PartyListResponseType_RETURN_ONLY_PARTY_INFORMATION_get, PartyListResponseType_RETURN_ONLY_PARTY_INFORMATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyListResponseType_RETURN_ALL_AVAILABLE_INFORMATION_ON_PARTIES_AND_RELATED_PARTIES",PartyListResponseType_RETURN_ALL_AVAILABLE_INFORMATION_ON_PARTIES_AND_RELATED_PARTIES_get, PartyListResponseType_RETURN_ALL_AVAILABLE_INFORMATION_ON_PARTIES_AND_RELATED_PARTIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyListResponseType_INCLUDE_RISK_LIMIT_INFORMATION",PartyListResponseType_INCLUDE_RISK_LIMIT_INFORMATION_get, PartyListResponseType_INCLUDE_RISK_LIMIT_INFORMATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyListResponseType_INCLUDE_INFORMATION_ON_RELATED_PARTIES",PartyListResponseType_INCLUDE_INFORMATION_ON_RELATED_PARTIES_get, PartyListResponseType_INCLUDE_INFORMATION_ON_RELATED_PARTIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqStatus_COMPLETED",PosReqStatus_COMPLETED_get, PosReqStatus_COMPLETED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqStatus_REJECTED",PosReqStatus_REJECTED_get, PosReqStatus_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqStatus_COMPLETEDWITHWARNINGS",PosReqStatus_COMPLETEDWITHWARNINGS_get, PosReqStatus_COMPLETEDWITHWARNINGS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqStatus_COMPLETED_WITH_WARNINGS",PosReqStatus_COMPLETED_WITH_WARNINGS_get, PosReqStatus_COMPLETED_WITH_WARNINGS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriorityIndicator_PRIORITY_UNCHANGED",PriorityIndicator_PRIORITY_UNCHANGED_get, PriorityIndicator_PRIORITY_UNCHANGED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriorityIndicator_PRIORITYUNCHANGED",PriorityIndicator_PRIORITYUNCHANGED_get, PriorityIndicator_PRIORITYUNCHANGED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriorityIndicator_LOSTPRIORITY",PriorityIndicator_LOSTPRIORITY_get, PriorityIndicator_LOSTPRIORITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriorityIndicator_LOST_PRIORITY_AS_RESULT_OF_ORDER_CHANGE",PriorityIndicator_LOST_PRIORITY_AS_RESULT_OF_ORDER_CHANGE_get, PriorityIndicator_LOST_PRIORITY_AS_RESULT_OF_ORDER_CHANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MoneyLaunderingStatus_NOTCHECKED",MoneyLaunderingStatus_NOTCHECKED_get, MoneyLaunderingStatus_NOTCHECKED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MoneyLaunderingStatus_EXEMPT_BELOW_THE_LIMIT",MoneyLaunderingStatus_EXEMPT_BELOW_THE_LIMIT_get, MoneyLaunderingStatus_EXEMPT_BELOW_THE_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MoneyLaunderingStatus_EXAUTHCREDIT",MoneyLaunderingStatus_EXAUTHCREDIT_get, MoneyLaunderingStatus_EXAUTHCREDIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MoneyLaunderingStatus_EXEMPT_CLIENT_MONEY_TYPE_EXEMPTION",MoneyLaunderingStatus_EXEMPT_CLIENT_MONEY_TYPE_EXEMPTION_get, MoneyLaunderingStatus_EXEMPT_CLIENT_MONEY_TYPE_EXEMPTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MoneyLaunderingStatus_EXEMPT_AUTHORISED_CREDIT_OR_FINANCIAL_INSTITUTION",MoneyLaunderingStatus_EXEMPT_AUTHORISED_CREDIT_OR_FINANCIAL_INSTITUTION_get, MoneyLaunderingStatus_EXEMPT_AUTHORISED_CREDIT_OR_FINANCIAL_INSTITUTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MoneyLaunderingStatus_NOT_CHECKED",MoneyLaunderingStatus_NOT_CHECKED_get, MoneyLaunderingStatus_NOT_CHECKED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MoneyLaunderingStatus_PASSED",MoneyLaunderingStatus_PASSED_get, MoneyLaunderingStatus_PASSED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MoneyLaunderingStatus_EXEMPT_1",MoneyLaunderingStatus_EXEMPT_1_get, MoneyLaunderingStatus_EXEMPT_1_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MoneyLaunderingStatus_EXCLIENTMONEYTYPE",MoneyLaunderingStatus_EXCLIENTMONEYTYPE_get, MoneyLaunderingStatus_EXCLIENTMONEYTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MoneyLaunderingStatus_EXEMPT_2",MoneyLaunderingStatus_EXEMPT_2_get, MoneyLaunderingStatus_EXEMPT_2_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MoneyLaunderingStatus_EXBELOWLIM",MoneyLaunderingStatus_EXBELOWLIM_get, MoneyLaunderingStatus_EXBELOWLIM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MoneyLaunderingStatus_EXEMPT_3",MoneyLaunderingStatus_EXEMPT_3_get, MoneyLaunderingStatus_EXEMPT_3_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LotType_ROUND_LOT_BASED_UPON_UNITOFMEASURE",LotType_ROUND_LOT_BASED_UPON_UNITOFMEASURE_get, LotType_ROUND_LOT_BASED_UPON_UNITOFMEASURE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LotType_ROUND_LOT",LotType_ROUND_LOT_get, LotType_ROUND_LOT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LotType_ODD_LOT",LotType_ODD_LOT_get, LotType_ODD_LOT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LotType_BLOCK_LOT",LotType_BLOCK_LOT_get, LotType_BLOCK_LOT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_FLAT_CURVE",QuoteCondition_FLAT_CURVE_get, QuoteCondition_FLAT_CURVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_REST_OF_BOOK_VWAP",QuoteCondition_REST_OF_BOOK_VWAP_get, QuoteCondition_REST_OF_BOOK_VWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_BETTER_PRICES_IN_CONDITIONAL_ORDERS",QuoteCondition_BETTER_PRICES_IN_CONDITIONAL_ORDERS_get, QuoteCondition_BETTER_PRICES_IN_CONDITIONAL_ORDERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_TRADING_RANGE",QuoteCondition_TRADING_RANGE_get, QuoteCondition_TRADING_RANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_HALT_ETH",QuoteCondition_HALT_ETH_get, QuoteCondition_HALT_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_BID_OFFER_SPECIALIST",QuoteCondition_BID_OFFER_SPECIALIST_get, QuoteCondition_BID_OFFER_SPECIALIST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_CONSOLBEST",QuoteCondition_CONSOLBEST_get, QuoteCondition_CONSOLBEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_CROSSED",QuoteCondition_CROSSED_get, QuoteCondition_CROSSED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_NO_OPEN",QuoteCondition_NO_OPEN_get, QuoteCondition_NO_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_HALT",QuoteCondition_HALT_get, QuoteCondition_HALT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_PREOPENING_SAM",QuoteCondition_PREOPENING_SAM_get, QuoteCondition_PREOPENING_SAM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_OPEN_SAM",QuoteCondition_OPEN_SAM_get, QuoteCondition_OPEN_SAM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_RESERVED_SAM",QuoteCondition_RESERVED_SAM_get, QuoteCondition_RESERVED_SAM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_OUTRIGHT_PRICE",QuoteCondition_OUTRIGHT_PRICE_get, QuoteCondition_OUTRIGHT_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_IMPLIED_PRICE",QuoteCondition_IMPLIED_PRICE_get, QuoteCondition_IMPLIED_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_DEPTH_ON_OFFER",QuoteCondition_DEPTH_ON_OFFER_get, QuoteCondition_DEPTH_ON_OFFER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_ADDITIONAL_INFO_DUE_TO_RELATED",QuoteCondition_ADDITIONAL_INFO_DUE_TO_RELATED_get, QuoteCondition_ADDITIONAL_INFO_DUE_TO_RELATED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_REGULAR_ETH",QuoteCondition_REGULAR_ETH_get, QuoteCondition_REGULAR_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_ROTATION_ETH",QuoteCondition_ROTATION_ETH_get, QuoteCondition_ROTATION_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_NONFIRM",QuoteCondition_NONFIRM_get, QuoteCondition_NONFIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_EXCHANGE_BEST",QuoteCondition_EXCHANGE_BEST_get, QuoteCondition_EXCHANGE_BEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_DEPTH_ON_BID",QuoteCondition_DEPTH_ON_BID_get, QuoteCondition_DEPTH_ON_BID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_CLOSING",QuoteCondition_CLOSING_get, QuoteCondition_CLOSING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_VIEW_OF_COMMON",QuoteCondition_VIEW_OF_COMMON_get, QuoteCondition_VIEW_OF_COMMON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_FORBIDDEN_SAM",QuoteCondition_FORBIDDEN_SAM_get, QuoteCondition_FORBIDDEN_SAM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_LOCKED",QuoteCondition_LOCKED_get, QuoteCondition_LOCKED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_ORDER_INFLUX",QuoteCondition_ORDER_INFLUX_get, QuoteCondition_ORDER_INFLUX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_NEWS_PENDING",QuoteCondition_NEWS_PENDING_get, QuoteCondition_NEWS_PENDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_RESUME",QuoteCondition_RESUME_get, QuoteCondition_RESUME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_TRADING_RESUME",QuoteCondition_TRADING_RESUME_get, QuoteCondition_TRADING_RESUME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_OUT_OF_SEQUENCE",QuoteCondition_OUT_OF_SEQUENCE_get, QuoteCondition_OUT_OF_SEQUENCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_END_OF_DAY_SAM",QuoteCondition_END_OF_DAY_SAM_get, QuoteCondition_END_OF_DAY_SAM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_FROZEN_SAM",QuoteCondition_FROZEN_SAM_get, QuoteCondition_FROZEN_SAM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_OPENING_SAM",QuoteCondition_OPENING_SAM_get, QuoteCondition_OPENING_SAM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_MANUAL_SLOW_QUOTE",QuoteCondition_MANUAL_SLOW_QUOTE_get, QuoteCondition_MANUAL_SLOW_QUOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_NEWS_DISSEMINATION",QuoteCondition_NEWS_DISSEMINATION_get, QuoteCondition_NEWS_DISSEMINATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_DUE_TO_RELATED",QuoteCondition_DUE_TO_RELATED_get, QuoteCondition_DUE_TO_RELATED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_VOLUME_ALERT",QuoteCondition_VOLUME_ALERT_get, QuoteCondition_VOLUME_ALERT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_FAST_MARKET_ETH",QuoteCondition_FAST_MARKET_ETH_get, QuoteCondition_FAST_MARKET_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_INACTIVE_ETH",QuoteCondition_INACTIVE_ETH_get, QuoteCondition_INACTIVE_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_DUE_TO_NEWS_DISSEMINATION",QuoteCondition_DUE_TO_NEWS_DISSEMINATION_get, QuoteCondition_DUE_TO_NEWS_DISSEMINATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_SURVEILLANCE_SAM",QuoteCondition_SURVEILLANCE_SAM_get, QuoteCondition_SURVEILLANCE_SAM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_DEPTH",QuoteCondition_DEPTH_get, QuoteCondition_DEPTH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_OPEN",QuoteCondition_OPEN_get, QuoteCondition_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_AUTOMATIC_EXECUTION",QuoteCondition_AUTOMATIC_EXECUTION_get, QuoteCondition_AUTOMATIC_EXECUTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_DUE_TO_NEWS_PENDING",QuoteCondition_DUE_TO_NEWS_PENDING_get, QuoteCondition_DUE_TO_NEWS_PENDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_NO_ACTIVE_SAM",QuoteCondition_NO_ACTIVE_SAM_get, QuoteCondition_NO_ACTIVE_SAM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_OFFER_SPECIALIST",QuoteCondition_OFFER_SPECIALIST_get, QuoteCondition_OFFER_SPECIALIST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_SUSPENDED_SAM",QuoteCondition_SUSPENDED_SAM_get, QuoteCondition_SUSPENDED_SAM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_RESTRICTED",QuoteCondition_RESTRICTED_get, QuoteCondition_RESTRICTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_NON_FIRM",QuoteCondition_NON_FIRM_get, QuoteCondition_NON_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_CLOSED_INACTIVE",QuoteCondition_CLOSED_INACTIVE_get, QuoteCondition_CLOSED_INACTIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_ADDITIONAL_INFO",QuoteCondition_ADDITIONAL_INFO_get, QuoteCondition_ADDITIONAL_INFO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_EQUIPMENT_CHANGEOVER",QuoteCondition_EQUIPMENT_CHANGEOVER_get, QuoteCondition_EQUIPMENT_CHANGEOVER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_EXCHBEST",QuoteCondition_EXCHBEST_get, QuoteCondition_EXCHBEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_FAST_TRADING",QuoteCondition_FAST_TRADING_get, QuoteCondition_FAST_TRADING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_FULL_CURVE",QuoteCondition_FULL_CURVE_get, QuoteCondition_FULL_CURVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_MEDIAN_PRICE",QuoteCondition_MEDIAN_PRICE_get, QuoteCondition_MEDIAN_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_OPEN_ACTIVE",QuoteCondition_OPEN_ACTIVE_get, QuoteCondition_OPEN_ACTIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_ORDER_IMBALANCE",QuoteCondition_ORDER_IMBALANCE_get, QuoteCondition_ORDER_IMBALANCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_AUTOMATIC_EXECUTION_ETH",QuoteCondition_AUTOMATIC_EXECUTION_ETH_get, QuoteCondition_AUTOMATIC_EXECUTION_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_ROTATION",QuoteCondition_ROTATION_get, QuoteCondition_ROTATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_BID_SPECIALIST",QuoteCondition_BID_SPECIALIST_get, QuoteCondition_BID_SPECIALIST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_FAST",QuoteCondition_FAST_get, QuoteCondition_FAST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_CONSOLIDATED_BEST",QuoteCondition_CONSOLIDATED_BEST_get, QuoteCondition_CONSOLIDATED_BEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_CLOSED",QuoteCondition_CLOSED_get, QuoteCondition_CLOSED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_OWNED_BY_30",PartyRelationship_OWNED_BY_30_get, PartyRelationship_OWNED_BY_30_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_PROVIDES_QUOTES_TO",PartyRelationship_PROVIDES_QUOTES_TO_get, PartyRelationship_PROVIDES_QUOTES_TO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_POSTS_TRADES_TO",PartyRelationship_POSTS_TRADES_TO_get, PartyRelationship_POSTS_TRADES_TO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_REGULATORY_OWNER_OF",PartyRelationship_REGULATORY_OWNER_OF_get, PartyRelationship_REGULATORY_OWNER_OF_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_SUBSIDIARY_OF",PartyRelationship_SUBSIDIARY_OF_get, PartyRelationship_SUBSIDIARY_OF_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_HAS_MEMBERS",PartyRelationship_HAS_MEMBERS_get, PartyRelationship_HAS_MEMBERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_ENTERS_TRADES_THROUGH",PartyRelationship_ENTERS_TRADES_THROUGH_get, PartyRelationship_ENTERS_TRADES_THROUGH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_BENEFICIAL_OWNER_OF",PartyRelationship_BENEFICIAL_OWNER_OF_get, PartyRelationship_BENEFICIAL_OWNER_OF_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_OWNED_BY_34",PartyRelationship_OWNED_BY_34_get, PartyRelationship_OWNED_BY_34_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_CONTROLS",PartyRelationship_CONTROLS_get, PartyRelationship_CONTROLS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_REQUESTS_QUOTES_FROM",PartyRelationship_REQUESTS_QUOTES_FROM_get, PartyRelationship_REQUESTS_QUOTES_FROM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_SPONSORS",PartyRelationship_SPONSORS_get, PartyRelationship_SPONSORS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_CLEARS_THROUGH",PartyRelationship_CLEARS_THROUGH_get, PartyRelationship_CLEARS_THROUGH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_OWNED_BY_36",PartyRelationship_OWNED_BY_36_get, PartyRelationship_OWNED_BY_36_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_BROKERS_TRADES_THROUGH",PartyRelationship_BROKERS_TRADES_THROUGH_get, PartyRelationship_BROKERS_TRADES_THROUGH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_INVESTS_THROUGH",PartyRelationship_INVESTS_THROUGH_get, PartyRelationship_INVESTS_THROUGH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_PARTICIPANT_OF_MARKETPLACE",PartyRelationship_PARTICIPANT_OF_MARKETPLACE_get, PartyRelationship_PARTICIPANT_OF_MARKETPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_LEGAL",PartyRelationship_LEGAL_get, PartyRelationship_LEGAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_ENTERS_TRADES_FOR",PartyRelationship_ENTERS_TRADES_FOR_get, PartyRelationship_ENTERS_TRADES_FOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_CARRIES_POSITIONS_FOR",PartyRelationship_CARRIES_POSITIONS_FOR_get, PartyRelationship_CARRIES_POSITIONS_FOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_IS_GUARANTEED_BY",PartyRelationship_IS_GUARANTEED_BY_get, PartyRelationship_IS_GUARANTEED_BY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_IS_CONTROLLED_BY",PartyRelationship_IS_CONTROLLED_BY_get, PartyRelationship_IS_CONTROLLED_BY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_PROVIDES_TRADING_SERVICES_FOR",PartyRelationship_PROVIDES_TRADING_SERVICES_FOR_get, PartyRelationship_PROVIDES_TRADING_SERVICES_FOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_IS_ALSO",PartyRelationship_IS_ALSO_get, PartyRelationship_IS_ALSO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_PARENT_FIRM_FOR",PartyRelationship_PARENT_FIRM_FOR_get, PartyRelationship_PARENT_FIRM_FOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_APPROVED_BY",PartyRelationship_APPROVED_BY_get, PartyRelationship_APPROVED_BY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_APPROVES_OF",PartyRelationship_APPROVES_OF_get, PartyRelationship_APPROVES_OF_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_USES_TRADING_SERVICES_OF",PartyRelationship_USES_TRADING_SERVICES_OF_get, PartyRelationship_USES_TRADING_SERVICES_OF_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_PROVIDES_GUARANTEE_FOR",PartyRelationship_PROVIDES_GUARANTEE_FOR_get, PartyRelationship_PROVIDES_GUARANTEE_FOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_SPONSORED_THROUGH",PartyRelationship_SPONSORED_THROUGH_get, PartyRelationship_SPONSORED_THROUGH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_TRADES_FOR",PartyRelationship_TRADES_FOR_get, PartyRelationship_TRADES_FOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_CLEARS_FOR",PartyRelationship_CLEARS_FOR_get, PartyRelationship_CLEARS_FOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_BROKERS_TRADES_FOR",PartyRelationship_BROKERS_TRADES_FOR_get, PartyRelationship_BROKERS_TRADES_FOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_INVESTS_FOR",PartyRelationship_INVESTS_FOR_get, PartyRelationship_INVESTS_FOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_PROVIDES_MARKETPLACE_FOR",PartyRelationship_PROVIDES_MARKETPLACE_FOR_get, PartyRelationship_PROVIDES_MARKETPLACE_FOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_MEMBER_OF",PartyRelationship_MEMBER_OF_get, PartyRelationship_MEMBER_OF_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRelationship_TRADES_THROUGH",PartyRelationship_TRADES_THROUGH_get, PartyRelationship_TRADES_THROUGH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlLocation_EUROCLEAR",SettlLocation_EUROCLEAR_get, SettlLocation_EUROCLEAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlLocation_CEDEL",SettlLocation_CEDEL_get, SettlLocation_CEDEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlLocation_PARTICIPANT_TRUST_COMPANY",SettlLocation_PARTICIPANT_TRUST_COMPANY_get, SettlLocation_PARTICIPANT_TRUST_COMPANY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlLocation_PHYSICAL",SettlLocation_PHYSICAL_get, SettlLocation_PHYSICAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlLocation_EURO_CLEAR",SettlLocation_EURO_CLEAR_get, SettlLocation_EURO_CLEAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlLocation_FEDERALBOOKENTRY",SettlLocation_FEDERALBOOKENTRY_get, SettlLocation_FEDERALBOOKENTRY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlLocation_PARTICIPANTTRUSTCOMPANY",SettlLocation_PARTICIPANTTRUSTCOMPANY_get, SettlLocation_PARTICIPANTTRUSTCOMPANY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlLocation_DEPOSITORY_TRUST_COMPANY",SettlLocation_DEPOSITORY_TRUST_COMPANY_get, SettlLocation_DEPOSITORY_TRUST_COMPANY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlLocation_DEPOSITORYTRUSTCOMPANY",SettlLocation_DEPOSITORYTRUSTCOMPANY_get, SettlLocation_DEPOSITORYTRUSTCOMPANY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlLocation_LOCAL_MARKET_SETTLE_LOCATION",SettlLocation_LOCAL_MARKET_SETTLE_LOCATION_get, SettlLocation_LOCAL_MARKET_SETTLE_LOCATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlLocation_LOCALMARKETSETTLELOCATION",SettlLocation_LOCALMARKETSETTLELOCATION_get, SettlLocation_LOCALMARKETSETTLELOCATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlLocation_FEDERAL_BOOK_ENTRY",SettlLocation_FEDERAL_BOOK_ENTRY_get, SettlLocation_FEDERAL_BOOK_ENTRY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionScope_LOCAL",DiscretionScope_LOCAL_get, DiscretionScope_LOCAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionScope_NATIONAL_EXCLUDING_LOCAL",DiscretionScope_NATIONAL_EXCLUDING_LOCAL_get, DiscretionScope_NATIONAL_EXCLUDING_LOCAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionScope_NATIONALEXCLUDINGLOCAL",DiscretionScope_NATIONALEXCLUDINGLOCAL_get, DiscretionScope_NATIONALEXCLUDINGLOCAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionScope_GLOBAL",DiscretionScope_GLOBAL_get, DiscretionScope_GLOBAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionScope_NATIONAL",DiscretionScope_NATIONAL_get, DiscretionScope_NATIONAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionScope_LOCALEXCHANGEECNATS",DiscretionScope_LOCALEXCHANGEECNATS_get, DiscretionScope_LOCALEXCHANGEECNATS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_NETWORKINGSUBACCT",OwnerType_NETWORKINGSUBACCT_get, OwnerType_NETWORKINGSUBACCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_PUBLIC_COMPANY",OwnerType_PUBLIC_COMPANY_get, OwnerType_PUBLIC_COMPANY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_INDIVIDUAL_TRUSTEE",OwnerType_INDIVIDUAL_TRUSTEE_get, OwnerType_INDIVIDUAL_TRUSTEE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_CUSTODIAN_UNDER_GIFTS_TO_MINORS_ACT",OwnerType_CUSTODIAN_UNDER_GIFTS_TO_MINORS_ACT_get, OwnerType_CUSTODIAN_UNDER_GIFTS_TO_MINORS_ACT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_INDIVIDUAL_INVESTOR",OwnerType_INDIVIDUAL_INVESTOR_get, OwnerType_INDIVIDUAL_INVESTOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_COMPANY_TRUSTEE",OwnerType_COMPANY_TRUSTEE_get, OwnerType_COMPANY_TRUSTEE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_CORPBODY",OwnerType_CORPBODY_get, OwnerType_CORPBODY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_INDIVTRUSTEE",OwnerType_INDIVTRUSTEE_get, OwnerType_INDIVTRUSTEE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_PENSIONPLAN",OwnerType_PENSIONPLAN_get, OwnerType_PENSIONPLAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_PRIVATE_COMPANY",OwnerType_PRIVATE_COMPANY_get, OwnerType_PRIVATE_COMPANY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_NETWORKING_SUB_ACCOUNT",OwnerType_NETWORKING_SUB_ACCOUNT_get, OwnerType_NETWORKING_SUB_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_NON_PROFITORG",OwnerType_NON_PROFITORG_get, OwnerType_NON_PROFITORG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_PRIVATECOMPANY",OwnerType_PRIVATECOMPANY_get, OwnerType_PRIVATECOMPANY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_PENSION_PLAN",OwnerType_PENSION_PLAN_get, OwnerType_PENSION_PLAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_COMPANYTRUSTEE",OwnerType_COMPANYTRUSTEE_get, OwnerType_COMPANYTRUSTEE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_TRUSTS",OwnerType_TRUSTS_get, OwnerType_TRUSTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_FIDUCIARIES",OwnerType_FIDUCIARIES_get, OwnerType_FIDUCIARIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_INDIVINVESTOR",OwnerType_INDIVINVESTOR_get, OwnerType_INDIVINVESTOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_NON_PROFIT_ORGANIZATION",OwnerType_NON_PROFIT_ORGANIZATION_get, OwnerType_NON_PROFIT_ORGANIZATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_CORPORATE_BODY",OwnerType_CORPORATE_BODY_get, OwnerType_CORPORATE_BODY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_PUBLICCOMPANY",OwnerType_PUBLICCOMPANY_get, OwnerType_PUBLICCOMPANY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_CUSTODIANMINORSACT",OwnerType_CUSTODIANMINORSACT_get, OwnerType_CUSTODIANMINORSACT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_NOMINEE",OwnerType_NOMINEE_get, OwnerType_NOMINEE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplQueueResolution_END_SESSION",ApplQueueResolution_END_SESSION_get, ApplQueueResolution_END_SESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplQueueResolution_QUEUEFLUSHED",ApplQueueResolution_QUEUEFLUSHED_get, ApplQueueResolution_QUEUEFLUSHED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplQueueResolution_QUEUE_FLUSHED",ApplQueueResolution_QUEUE_FLUSHED_get, ApplQueueResolution_QUEUE_FLUSHED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplQueueResolution_ENDSESSION",ApplQueueResolution_ENDSESSION_get, ApplQueueResolution_ENDSESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplQueueResolution_OVERLAYLAST",ApplQueueResolution_OVERLAYLAST_get, ApplQueueResolution_OVERLAYLAST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplQueueResolution_OVERLAY_LAST",ApplQueueResolution_OVERLAY_LAST_get, ApplQueueResolution_OVERLAY_LAST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplQueueResolution_NOACTIONTAKEN",ApplQueueResolution_NOACTIONTAKEN_get, ApplQueueResolution_NOACTIONTAKEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplQueueResolution_NO_ACTION_TAKEN",ApplQueueResolution_NO_ACTION_TAKEN_get, ApplQueueResolution_NO_ACTION_TAKEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteResponseLevel_SUMMARY_ACKNOWLEDGEMENT",QuoteResponseLevel_SUMMARY_ACKNOWLEDGEMENT_get, QuoteResponseLevel_SUMMARY_ACKNOWLEDGEMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteResponseLevel_ACKEACH",QuoteResponseLevel_ACKEACH_get, QuoteResponseLevel_ACKEACH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteResponseLevel_ACKNOWLEDGE_ONLY_NEGATIVE_OR_ERRONEOUS_QUOTES",QuoteResponseLevel_ACKNOWLEDGE_ONLY_NEGATIVE_OR_ERRONEOUS_QUOTES_get, QuoteResponseLevel_ACKNOWLEDGE_ONLY_NEGATIVE_OR_ERRONEOUS_QUOTES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteResponseLevel_ACKNEG",QuoteResponseLevel_ACKNEG_get, QuoteResponseLevel_ACKNEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteResponseLevel_NOACK",QuoteResponseLevel_NOACK_get, QuoteResponseLevel_NOACK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGE",QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGE_get, QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGES",QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGES_get, QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteResponseLevel_NO_ACKNOWLEDGEMENT",QuoteResponseLevel_NO_ACKNOWLEDGEMENT_get, QuoteResponseLevel_NO_ACKNOWLEDGEMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecAckStatus_RECEIVED_NOT_YET_PROCESSED",ExecAckStatus_RECEIVED_NOT_YET_PROCESSED_get, ExecAckStatus_RECEIVED_NOT_YET_PROCESSED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecAckStatus_DONT_KNOW",ExecAckStatus_DONT_KNOW_get, ExecAckStatus_DONT_KNOW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecAckStatus_ACCEPTED",ExecAckStatus_ACCEPTED_get, ExecAckStatus_ACCEPTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NetGrossInd_NET",NetGrossInd_NET_get, NetGrossInd_NET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NetGrossInd_GROSS",NetGrossInd_GROSS_get, NetGrossInd_GROSS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlType_PARTIAL_CANCEL",CxlType_PARTIAL_CANCEL_get, CxlType_PARTIAL_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlType_FULL_REMAINING_QUANTITY",CxlType_FULL_REMAINING_QUANTITY_get, CxlType_FULL_REMAINING_QUANTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskTypeSource_NASD_OATS",DeskTypeSource_NASD_OATS_get, DeskTypeSource_NASD_OATS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionRoundDirection_MOREPASSIVE",DiscretionRoundDirection_MOREPASSIVE_get, DiscretionRoundDirection_MOREPASSIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionRoundDirection_MOREAGGRESSIVE",DiscretionRoundDirection_MOREAGGRESSIVE_get, DiscretionRoundDirection_MOREAGGRESSIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionRoundDirection_MORE_AGGRESSIVE",DiscretionRoundDirection_MORE_AGGRESSIVE_get, DiscretionRoundDirection_MORE_AGGRESSIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionRoundDirection_MORE_PASSIVE",DiscretionRoundDirection_MORE_PASSIVE_get, DiscretionRoundDirection_MORE_PASSIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidDescriptorType_COUNTRY",BidDescriptorType_COUNTRY_get, BidDescriptorType_COUNTRY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidDescriptorType_INDEX",BidDescriptorType_INDEX_get, BidDescriptorType_INDEX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidDescriptorType_SECTOR",BidDescriptorType_SECTOR_get, BidDescriptorType_SECTOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NetworkStatusResponseType_INCREMENTAL_UPDATE",NetworkStatusResponseType_INCREMENTAL_UPDATE_get, NetworkStatusResponseType_INCREMENTAL_UPDATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NetworkStatusResponseType_INCREMENTALUPDATE",NetworkStatusResponseType_INCREMENTALUPDATE_get, NetworkStatusResponseType_INCREMENTALUPDATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NetworkStatusResponseType_FULL",NetworkStatusResponseType_FULL_get, NetworkStatusResponseType_FULL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteType_INDICATIVE",QuoteType_INDICATIVE_get, QuoteType_INDICATIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteType_RESTRICTEDTRADEABLE",QuoteType_RESTRICTEDTRADEABLE_get, QuoteType_RESTRICTEDTRADEABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteType_RESTRICTED_TRADEABLE",QuoteType_RESTRICTED_TRADEABLE_get, QuoteType_RESTRICTED_TRADEABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteType_TRADEABLE",QuoteType_TRADEABLE_get, QuoteType_TRADEABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteType_COUNTER",QuoteType_COUNTER_get, QuoteType_COUNTER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionInst_RELVWAP",DiscretionInst_RELVWAP_get, DiscretionInst_RELVWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionInst_RELLOCPRIMPX",DiscretionInst_RELLOCPRIMPX_get, DiscretionInst_RELLOCPRIMPX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionInst_RELATED_TO_MARKET_PRICE",DiscretionInst_RELATED_TO_MARKET_PRICE_get, DiscretionInst_RELATED_TO_MARKET_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionInst_RELMIDPX",DiscretionInst_RELMIDPX_get, DiscretionInst_RELMIDPX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionInst_RELATED_TO_VWAP",DiscretionInst_RELATED_TO_VWAP_get, DiscretionInst_RELATED_TO_VWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionInst_RELATED_TO_MIDPOINT_PRICE",DiscretionInst_RELATED_TO_MIDPOINT_PRICE_get, DiscretionInst_RELATED_TO_MIDPOINT_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionInst_RELDISPPX",DiscretionInst_RELDISPPX_get, DiscretionInst_RELDISPPX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionInst_RELATED_TO_DISPLAYED_PRICE",DiscretionInst_RELATED_TO_DISPLAYED_PRICE_get, DiscretionInst_RELATED_TO_DISPLAYED_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionInst_RELATED_TO_PRIMARY_PRICE",DiscretionInst_RELATED_TO_PRIMARY_PRICE_get, DiscretionInst_RELATED_TO_PRIMARY_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionInst_AVERAGE_PRICE_GUARANTEE",DiscretionInst_AVERAGE_PRICE_GUARANTEE_get, DiscretionInst_AVERAGE_PRICE_GUARANTEE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionInst_RELMKTPX",DiscretionInst_RELMKTPX_get, DiscretionInst_RELMKTPX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionInst_RELPRIMPX",DiscretionInst_RELPRIMPX_get, DiscretionInst_RELPRIMPX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionInst_RELLSTPX",DiscretionInst_RELLSTPX_get, DiscretionInst_RELLSTPX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionInst_RELATED_TO_LAST_TRADE_PRICE",DiscretionInst_RELATED_TO_LAST_TRADE_PRICE_get, DiscretionInst_RELATED_TO_LAST_TRADE_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionInst_RELATED_TO_LOCAL_PRIMARY_PRICE",DiscretionInst_RELATED_TO_LOCAL_PRIMARY_PRICE_get, DiscretionInst_RELATED_TO_LOCAL_PRIMARY_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CrossPrioritization_BUY_SIDE_IS_PRIORITIZED",CrossPrioritization_BUY_SIDE_IS_PRIORITIZED_get, CrossPrioritization_BUY_SIDE_IS_PRIORITIZED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CrossPrioritization_SELL_SIDE_IS_PRIORITIZED",CrossPrioritization_SELL_SIDE_IS_PRIORITIZED_get, CrossPrioritization_SELL_SIDE_IS_PRIORITIZED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CrossPrioritization_BUY_SIDE_PRIORITIZED",CrossPrioritization_BUY_SIDE_PRIORITIZED_get, CrossPrioritization_BUY_SIDE_PRIORITIZED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CrossPrioritization_SELL_SIDE_PRIORITIZED",CrossPrioritization_SELL_SIDE_PRIORITIZED_get, CrossPrioritization_SELL_SIDE_PRIORITIZED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CrossPrioritization_NONE",CrossPrioritization_NONE_get, CrossPrioritization_NONE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CrossPrioritization_SELLSIDE_PRIORITIZED",CrossPrioritization_SELLSIDE_PRIORITIZED_get, CrossPrioritization_SELLSIDE_PRIORITIZED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CrossPrioritization_BUYSIDE_PRIORITIZED",CrossPrioritization_BUYSIDE_PRIORITIZED_get, CrossPrioritization_BUYSIDE_PRIORITIZED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIOthSvc_AUTEX",IOIOthSvc_AUTEX_get, IOIOthSvc_AUTEX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIOthSvc_BRIDGE",IOIOthSvc_BRIDGE_get, IOIOthSvc_BRIDGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_UNSUPPSUB",MDReqRejReason_UNSUPPSUB_get, MDReqRejReason_UNSUPPSUB_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_UNSUPPORTED_MDENTRYTYPE",MDReqRejReason_UNSUPPORTED_MDENTRYTYPE_get, MDReqRejReason_UNSUPPORTED_MDENTRYTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_INSUFFICIENT_CREDIT",MDReqRejReason_INSUFFICIENT_CREDIT_get, MDReqRejReason_INSUFFICIENT_CREDIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_UNSUPPMKTDEPTH",MDReqRejReason_UNSUPPMKTDEPTH_get, MDReqRejReason_UNSUPPMKTDEPTH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_UNSUPPENTRY",MDReqRejReason_UNSUPPENTRY_get, MDReqRejReason_UNSUPPENTRY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_INSUFFICIENT_BANDWIDTH",MDReqRejReason_INSUFFICIENT_BANDWIDTH_get, MDReqRejReason_INSUFFICIENT_BANDWIDTH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_UNSUPPORTED_SCOPE",MDReqRejReason_UNSUPPORTED_SCOPE_get, MDReqRejReason_UNSUPPORTED_SCOPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_UNSUPPMDIMPLICITDELETE",MDReqRejReason_UNSUPPMDIMPLICITDELETE_get, MDReqRejReason_UNSUPPMDIMPLICITDELETE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_UNSUPPORTED_TRADINGSESSIONID",MDReqRejReason_UNSUPPORTED_TRADINGSESSIONID_get, MDReqRejReason_UNSUPPORTED_TRADINGSESSIONID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_UNKNOWNSYM",MDReqRejReason_UNKNOWNSYM_get, MDReqRejReason_UNKNOWNSYM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_UNSUPPMDUPDATE",MDReqRejReason_UNSUPPMDUPDATE_get, MDReqRejReason_UNSUPPMDUPDATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_UNSUPPPOSITIONEFFECTSETTLEFLAG",MDReqRejReason_UNSUPPPOSITIONEFFECTSETTLEFLAG_get, MDReqRejReason_UNSUPPPOSITIONEFFECTSETTLEFLAG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_DUPLICATE_MDREQID",MDReqRejReason_DUPLICATE_MDREQID_get, MDReqRejReason_DUPLICATE_MDREQID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_DUPID",MDReqRejReason_DUPID_get, MDReqRejReason_DUPID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_UNSUPPORTED_AGGREGATEDBOOK",MDReqRejReason_UNSUPPORTED_AGGREGATEDBOOK_get, MDReqRejReason_UNSUPPORTED_AGGREGATEDBOOK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_UNSUPPORTED_MDUPDATETYPE",MDReqRejReason_UNSUPPORTED_MDUPDATETYPE_get, MDReqRejReason_UNSUPPORTED_MDUPDATETYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_UNSUPPORTED_SUBSCRIPTIONREQUESTTYPE",MDReqRejReason_UNSUPPORTED_SUBSCRIPTIONREQUESTTYPE_get, MDReqRejReason_UNSUPPORTED_SUBSCRIPTIONREQUESTTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_UNKNOWN_SYMBOL",MDReqRejReason_UNKNOWN_SYMBOL_get, MDReqRejReason_UNKNOWN_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_INSBAND",MDReqRejReason_INSBAND_get, MDReqRejReason_INSBAND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_UNSUPPSCOPE",MDReqRejReason_UNSUPPSCOPE_get, MDReqRejReason_UNSUPPSCOPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_UNSUPPORTED_OPENCLOSESETTLEFLAG",MDReqRejReason_UNSUPPORTED_OPENCLOSESETTLEFLAG_get, MDReqRejReason_UNSUPPORTED_OPENCLOSESETTLEFLAG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_UNSUPPORTED_MARKETDEPTH",MDReqRejReason_UNSUPPORTED_MARKETDEPTH_get, MDReqRejReason_UNSUPPORTED_MARKETDEPTH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_UNSUPPAGGBK",MDReqRejReason_UNSUPPAGGBK_get, MDReqRejReason_UNSUPPAGGBK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_INSUFFICIENT_PERMISSIONS",MDReqRejReason_INSUFFICIENT_PERMISSIONS_get, MDReqRejReason_INSUFFICIENT_PERMISSIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_INSPERM",MDReqRejReason_INSPERM_get, MDReqRejReason_INSPERM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_UNSUPPTRDSESSIONID",MDReqRejReason_UNSUPPTRDSESSIONID_get, MDReqRejReason_UNSUPPTRDSESSIONID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_UNSUPPORTED_MDIMPLICITDELETE",MDReqRejReason_UNSUPPORTED_MDIMPLICITDELETE_get, MDReqRejReason_UNSUPPORTED_MDIMPLICITDELETE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplReqType_REQUEST_FOR_THE_LAST_APPLLASTSEQNUM_PUBLISHED_FOR_THE_SPECIFIED_APPLICATIONS",ApplReqType_REQUEST_FOR_THE_LAST_APPLLASTSEQNUM_PUBLISHED_FOR_THE_SPECIFIED_APPLICATIONS_get, ApplReqType_REQUEST_FOR_THE_LAST_APPLLASTSEQNUM_PUBLISHED_FOR_THE_SPECIFIED_APPLICATIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplReqType_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS",ApplReqType_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS_get, ApplReqType_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplReqType_CANCEL_RETRANSMISSION_AND_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS",ApplReqType_CANCEL_RETRANSMISSION_AND_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS_get, ApplReqType_CANCEL_RETRANSMISSION_AND_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplReqType_SUBSCRIPTION_TO_THE_SPECIFIED_APPLICATIONS",ApplReqType_SUBSCRIPTION_TO_THE_SPECIFIED_APPLICATIONS_get, ApplReqType_SUBSCRIPTION_TO_THE_SPECIFIED_APPLICATIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplReqType_RETRANSMISSION_OF_APPLICATION_MESSAGES_FOR_THE_SPECIFIED_APPLICATIONS",ApplReqType_RETRANSMISSION_OF_APPLICATION_MESSAGES_FOR_THE_SPECIFIED_APPLICATIONS_get, ApplReqType_RETRANSMISSION_OF_APPLICATION_MESSAGES_FOR_THE_SPECIFIED_APPLICATIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplReqType_REQUEST_VALID_SET_OF_APPLICATIONS",ApplReqType_REQUEST_VALID_SET_OF_APPLICATIONS_get, ApplReqType_REQUEST_VALID_SET_OF_APPLICATIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplReqType_CANCEL_RETRANSMISSION",ApplReqType_CANCEL_RETRANSMISSION_get, ApplReqType_CANCEL_RETRANSMISSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AggressorIndicator_NO",AggressorIndicator_NO_get, AggressorIndicator_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AggressorIndicator_YES",AggressorIndicator_YES_get, AggressorIndicator_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_APPNA",BusinessRejectReason_APPNA_get, BusinessRejectReason_APPNA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_UNKNOWN_SECURITY",BusinessRejectReason_UNKNOWN_SECURITY_get, BusinessRejectReason_UNKNOWN_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_UNKNMSGTYPE",BusinessRejectReason_UNKNMSGTYPE_get, BusinessRejectReason_UNKNMSGTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_CONDFLDMISS",BusinessRejectReason_CONDFLDMISS_get, BusinessRejectReason_CONDFLDMISS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_UNKNID",BusinessRejectReason_UNKNID_get, BusinessRejectReason_UNKNID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_APPLICATION_NOT_AVAILABLE",BusinessRejectReason_APPLICATION_NOT_AVAILABLE_get, BusinessRejectReason_APPLICATION_NOT_AVAILABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_INVALID_PRICE_INCREMENT",BusinessRejectReason_INVALID_PRICE_INCREMENT_get, BusinessRejectReason_INVALID_PRICE_INCREMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME",BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_get, BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING",BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_get, BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_UNKNOWN_ID",BusinessRejectReason_UNKNOWN_ID_get, BusinessRejectReason_UNKNOWN_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_NOTAUTH",BusinessRejectReason_NOTAUTH_get, BusinessRejectReason_NOTAUTH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_NODELIVTOFIRM",BusinessRejectReason_NODELIVTOFIRM_get, BusinessRejectReason_NODELIVTOFIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_OTHER",BusinessRejectReason_OTHER_get, BusinessRejectReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE",BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_get, BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_UNKNOWN_MESSAGE_TYPE",BusinessRejectReason_UNKNOWN_MESSAGE_TYPE_get, BusinessRejectReason_UNKNOWN_MESSAGE_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_NOT_AUTHORIZED",BusinessRejectReason_NOT_AUTHORIZED_get, BusinessRejectReason_NOT_AUTHORIZED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_UNKNSEC",BusinessRejectReason_UNKNSEC_get, BusinessRejectReason_UNKNSEC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_UNKOWN_ID",BusinessRejectReason_UNKOWN_ID_get, BusinessRejectReason_UNKOWN_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BookingType_REGULAR_BOOKING",BookingType_REGULAR_BOOKING_get, BookingType_REGULAR_BOOKING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BookingType_REGULARBOOKING",BookingType_REGULARBOOKING_get, BookingType_REGULARBOOKING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BookingType_CFD",BookingType_CFD_get, BookingType_CFD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BookingType_CFDCONTRACTFORDIFFERENCE",BookingType_CFDCONTRACTFORDIFFERENCE_get, BookingType_CFDCONTRACTFORDIFFERENCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BookingType_TOTALRETURNSWAP",BookingType_TOTALRETURNSWAP_get, BookingType_TOTALRETURNSWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BookingType_TOTAL_RETURN_SWAP",BookingType_TOTAL_RETURN_SWAP_get, BookingType_TOTAL_RETURN_SWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BEGINSTRING",BEGINSTRING_get, BEGINSTRING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SENDERCOMPID",SENDERCOMPID_get, SENDERCOMPID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TARGETCOMPID",TARGETCOMPID_get, TARGETCOMPID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SESSION_QUALIFIER",SESSION_QUALIFIER_get, SESSION_QUALIFIER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DEFAULT_APPLVERID",DEFAULT_APPLVERID_get, DEFAULT_APPLVERID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CONNECTION_TYPE",CONNECTION_TYPE_get, CONNECTION_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"USE_DATA_DICTIONARY",USE_DATA_DICTIONARY_get, USE_DATA_DICTIONARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SEND_RESETSEQNUMFLAG",SEND_RESETSEQNUMFLAG_get, SEND_RESETSEQNUMFLAG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SEND_REDUNDANT_RESENDREQUESTS",SEND_REDUNDANT_RESENDREQUESTS_get, SEND_REDUNDANT_RESENDREQUESTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DATA_DICTIONARY",DATA_DICTIONARY_get, DATA_DICTIONARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TRANSPORT_DATA_DICTIONARY",TRANSPORT_DATA_DICTIONARY_get, TRANSPORT_DATA_DICTIONARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"APP_DATA_DICTIONARY",APP_DATA_DICTIONARY_get, APP_DATA_DICTIONARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"USE_LOCAL_TIME",USE_LOCAL_TIME_get, USE_LOCAL_TIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"START_TIME",START_TIME_get, START_TIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"END_TIME",END_TIME_get, END_TIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"START_DAY",START_DAY_get, START_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"END_DAY",END_DAY_get, END_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LOGON_TIME",LOGON_TIME_get, LOGON_TIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LOGOUT_TIME",LOGOUT_TIME_get, LOGOUT_TIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LOGON_DAY",LOGON_DAY_get, LOGON_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LOGOUT_DAY",LOGOUT_DAY_get, LOGOUT_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CHECK_COMPID",CHECK_COMPID_get, CHECK_COMPID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CHECK_LATENCY",CHECK_LATENCY_get, CHECK_LATENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MAX_LATENCY",MAX_LATENCY_get, MAX_LATENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HEARTBTINT",HEARTBTINT_get, HEARTBTINT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SOCKET_ACCEPT_PORT",SOCKET_ACCEPT_PORT_get, SOCKET_ACCEPT_PORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SOCKET_REUSE_ADDRESS",SOCKET_REUSE_ADDRESS_get, SOCKET_REUSE_ADDRESS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SOCKET_CONNECT_HOST",SOCKET_CONNECT_HOST_get, SOCKET_CONNECT_HOST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SOCKET_CONNECT_PORT",SOCKET_CONNECT_PORT_get, SOCKET_CONNECT_PORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SOCKET_NODELAY",SOCKET_NODELAY_get, SOCKET_NODELAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SOCKET_SEND_BUFFER_SIZE",SOCKET_SEND_BUFFER_SIZE_get, SOCKET_SEND_BUFFER_SIZE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SOCKET_RECEIVE_BUFFER_SIZE",SOCKET_RECEIVE_BUFFER_SIZE_get, SOCKET_RECEIVE_BUFFER_SIZE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RECONNECT_INTERVAL",RECONNECT_INTERVAL_get, RECONNECT_INTERVAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"VALIDATE_FIELDS_OUT_OF_ORDER",VALIDATE_FIELDS_OUT_OF_ORDER_get, VALIDATE_FIELDS_OUT_OF_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"VALIDATE_FIELDS_HAVE_VALUES",VALIDATE_FIELDS_HAVE_VALUES_get, VALIDATE_FIELDS_HAVE_VALUES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"VALIDATE_USER_DEFINED_FIELDS",VALIDATE_USER_DEFINED_FIELDS_get, VALIDATE_USER_DEFINED_FIELDS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LOGON_TIMEOUT",LOGON_TIMEOUT_get, LOGON_TIMEOUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LOGOUT_TIMEOUT",LOGOUT_TIMEOUT_get, LOGOUT_TIMEOUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FILE_STORE_PATH",FILE_STORE_PATH_get, FILE_STORE_PATH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MYSQL_STORE_USECONNECTIONPOOL",MYSQL_STORE_USECONNECTIONPOOL_get, MYSQL_STORE_USECONNECTIONPOOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MYSQL_STORE_DATABASE",MYSQL_STORE_DATABASE_get, MYSQL_STORE_DATABASE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MYSQL_STORE_USER",MYSQL_STORE_USER_get, MYSQL_STORE_USER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MYSQL_STORE_PASSWORD",MYSQL_STORE_PASSWORD_get, MYSQL_STORE_PASSWORD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MYSQL_STORE_HOST",MYSQL_STORE_HOST_get, MYSQL_STORE_HOST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MYSQL_STORE_PORT",MYSQL_STORE_PORT_get, MYSQL_STORE_PORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"POSTGRESQL_STORE_USECONNECTIONPOOL",POSTGRESQL_STORE_USECONNECTIONPOOL_get, POSTGRESQL_STORE_USECONNECTIONPOOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"POSTGRESQL_STORE_DATABASE",POSTGRESQL_STORE_DATABASE_get, POSTGRESQL_STORE_DATABASE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"POSTGRESQL_STORE_USER",POSTGRESQL_STORE_USER_get, POSTGRESQL_STORE_USER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"POSTGRESQL_STORE_PASSWORD",POSTGRESQL_STORE_PASSWORD_get, POSTGRESQL_STORE_PASSWORD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"POSTGRESQL_STORE_HOST",POSTGRESQL_STORE_HOST_get, POSTGRESQL_STORE_HOST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"POSTGRESQL_STORE_PORT",POSTGRESQL_STORE_PORT_get, POSTGRESQL_STORE_PORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ODBC_STORE_USER",ODBC_STORE_USER_get, ODBC_STORE_USER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ODBC_STORE_PASSWORD",ODBC_STORE_PASSWORD_get, ODBC_STORE_PASSWORD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ODBC_STORE_CONNECTION_STRING",ODBC_STORE_CONNECTION_STRING_get, ODBC_STORE_CONNECTION_STRING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FILE_LOG_PATH",FILE_LOG_PATH_get, FILE_LOG_PATH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FILE_LOG_BACKUP_PATH",FILE_LOG_BACKUP_PATH_get, FILE_LOG_BACKUP_PATH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SCREEN_LOG_SHOW_INCOMING",SCREEN_LOG_SHOW_INCOMING_get, SCREEN_LOG_SHOW_INCOMING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SCREEN_LOG_SHOW_OUTGOING",SCREEN_LOG_SHOW_OUTGOING_get, SCREEN_LOG_SHOW_OUTGOING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SCREEN_LOG_SHOW_EVENTS",SCREEN_LOG_SHOW_EVENTS_get, SCREEN_LOG_SHOW_EVENTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MYSQL_LOG_USECONNECTIONPOOL",MYSQL_LOG_USECONNECTIONPOOL_get, MYSQL_LOG_USECONNECTIONPOOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MYSQL_LOG_DATABASE",MYSQL_LOG_DATABASE_get, MYSQL_LOG_DATABASE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MYSQL_LOG_USER",MYSQL_LOG_USER_get, MYSQL_LOG_USER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MYSQL_LOG_PASSWORD",MYSQL_LOG_PASSWORD_get, MYSQL_LOG_PASSWORD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MYSQL_LOG_HOST",MYSQL_LOG_HOST_get, MYSQL_LOG_HOST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MYSQL_LOG_PORT",MYSQL_LOG_PORT_get, MYSQL_LOG_PORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MYSQL_LOG_INCOMING_TABLE",MYSQL_LOG_INCOMING_TABLE_get, MYSQL_LOG_INCOMING_TABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MYSQL_LOG_OUTGOING_TABLE",MYSQL_LOG_OUTGOING_TABLE_get, MYSQL_LOG_OUTGOING_TABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MYSQL_LOG_EVENT_TABLE",MYSQL_LOG_EVENT_TABLE_get, MYSQL_LOG_EVENT_TABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"POSTGRESQL_LOG_USECONNECTIONPOOL",POSTGRESQL_LOG_USECONNECTIONPOOL_get, POSTGRESQL_LOG_USECONNECTIONPOOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"POSTGRESQL_LOG_DATABASE",POSTGRESQL_LOG_DATABASE_get, POSTGRESQL_LOG_DATABASE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"POSTGRESQL_LOG_USER",POSTGRESQL_LOG_USER_get, POSTGRESQL_LOG_USER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"POSTGRESQL_LOG_PASSWORD",POSTGRESQL_LOG_PASSWORD_get, POSTGRESQL_LOG_PASSWORD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"POSTGRESQL_LOG_HOST",POSTGRESQL_LOG_HOST_get, POSTGRESQL_LOG_HOST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"POSTGRESQL_LOG_PORT",POSTGRESQL_LOG_PORT_get, POSTGRESQL_LOG_PORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"POSTGRESQL_LOG_INCOMING_TABLE",POSTGRESQL_LOG_INCOMING_TABLE_get, POSTGRESQL_LOG_INCOMING_TABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"POSTGRESQL_LOG_OUTGOING_TABLE",POSTGRESQL_LOG_OUTGOING_TABLE_get, POSTGRESQL_LOG_OUTGOING_TABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"POSTGRESQL_LOG_EVENT_TABLE",POSTGRESQL_LOG_EVENT_TABLE_get, POSTGRESQL_LOG_EVENT_TABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ODBC_LOG_USER",ODBC_LOG_USER_get, ODBC_LOG_USER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ODBC_LOG_PASSWORD",ODBC_LOG_PASSWORD_get, ODBC_LOG_PASSWORD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ODBC_LOG_CONNECTION_STRING",ODBC_LOG_CONNECTION_STRING_get, ODBC_LOG_CONNECTION_STRING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ODBC_LOG_INCOMING_TABLE",ODBC_LOG_INCOMING_TABLE_get, ODBC_LOG_INCOMING_TABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ODBC_LOG_OUTGOING_TABLE",ODBC_LOG_OUTGOING_TABLE_get, ODBC_LOG_OUTGOING_TABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ODBC_LOG_EVENT_TABLE",ODBC_LOG_EVENT_TABLE_get, ODBC_LOG_EVENT_TABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RESET_ON_LOGON",RESET_ON_LOGON_get, RESET_ON_LOGON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RESET_ON_LOGOUT",RESET_ON_LOGOUT_get, RESET_ON_LOGOUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RESET_ON_DISCONNECT",RESET_ON_DISCONNECT_get, RESET_ON_DISCONNECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"REFRESH_ON_LOGON",REFRESH_ON_LOGON_get, REFRESH_ON_LOGON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MILLISECONDS_IN_TIMESTAMP",MILLISECONDS_IN_TIMESTAMP_get, MILLISECONDS_IN_TIMESTAMP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HTTP_ACCEPT_PORT",HTTP_ACCEPT_PORT_get, HTTP_ACCEPT_PORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PERSIST_MESSAGES",PERSIST_MESSAGES_get, PERSIST_MESSAGES_set);
  
  /* Initialize threading */
  SWIG_PYTHON_INITIALIZE_THREADS;
}

